@duplojs/lang 0.0.1-beta.5 → 0.0.1-beta.6

package/dist/common/constraint/cast/string.d.ts

@@ -9,10 +9,14 @@ export interface ComputeCastConstraintStringRule<GenericValue extends string, Ge
     lengthEqual: GenericExpectedConstraint extends DString.LengthEqual<number> ? DCommon.NeverCoalescing<(DString.ComputeLengthEqualCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : CastError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on LengthEqual because value does not have LengthEqual constraint.", GenericValue, GenericExpectedConstraint>> : never;
     path: DCommon.IsExtends<GenericExpectedConstraint, DPath.Path> extends true ? DCommon.Or<[
         DPath.IsLiteralPath<GenericValue>,
-        DCommon.IsExtends<GenericValue, DPath.Path | DPath.Absolute>
+        DCommon.IsExtends<GenericValue, DPath.Path | DPath.Absolute | DPath.Segment>
     ]> extends true ? unknown : CastError<`Impossible to cast on Path because value ${GenericValue} is not path.`, GenericValue, GenericExpectedConstraint> : never;
     absolutePath: DCommon.IsExtends<GenericExpectedConstraint, DPath.Absolute> extends true ? DCommon.Or<[
         DPath.IsLiteralAbsolutePath<GenericValue>,
         DCommon.IsExtends<GenericValue, DPath.Absolute>
-    ]> extends true ? unknown : CastError<`Impossible to cast on Absolute Path because value ${GenericValue} is not absolute path.`, GenericValue, GenericExpectedConstraint> : never;
+    ]> extends true ? unknown : CastError<`Impossible to cast on AbsolutePath because value ${GenericValue} is not absolute path.`, GenericValue, GenericExpectedConstraint> : never;
+    segment: DCommon.IsExtends<GenericExpectedConstraint, DPath.Segment> extends true ? DCommon.Or<[
+        DPath.IsLiteralSegmentPath<GenericValue>,
+        DCommon.IsExtends<GenericValue, DPath.Segment>
+    ]> extends true ? unknown : CastError<`Impossible to cast on SegmentPath because value ${GenericValue} is not segment path.`, GenericValue, GenericExpectedConstraint> : never;
 }

package/dist/common/constraint/infer/string.d.ts

@@ -5,6 +5,7 @@ export interface ComputeInferConstraintStringRule<GenericInput extends string, G
     maxCharacters: DString.ComputeMaxCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.MaxCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MaxCharacters<${InferredResult["to"]}> because constraint MaxCharacters<${InferredResult["from"]}> from the value is more than.`> : never;
     minCharacters: DString.ComputeMinCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.MinCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MinCharacters<${InferredResult["to"]}> because constraint MinCharacters<${InferredResult["from"]}> from the value is less than.`> : never;
     lengthEqual: DString.ComputeLengthEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.LengthEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`> : never;
-    path: DCommon.IsExtends<GenericOutput, DPath.Path | DPath.Absolute> extends true ? DPath.IsLiteralPath<GenericInput> extends true ? DPath.Path : DCommon.ComputedTypeError<`Impossible to cast on Path because value ${GenericInput} is not path.`> : never;
-    absolutePath: DCommon.IsExtends<GenericOutput, DPath.Absolute> extends true ? DPath.IsLiteralAbsolutePath<GenericInput> extends true ? DPath.Absolute : DCommon.ComputedTypeError<`Impossible to cast on Absolute Path because value ${GenericInput} is not absolute path.`> : never;
+    path: DCommon.IsExtends<GenericOutput, DPath.Path> extends true ? DPath.IsLiteralPath<GenericInput> extends true ? DPath.Path : DCommon.ComputedTypeError<`Impossible to cast on Path because value ${GenericInput} is not path.`> : never;
+    absolutePath: DCommon.IsExtends<GenericOutput, DPath.Absolute> extends true ? DPath.IsLiteralAbsolutePath<GenericInput> extends true ? DPath.Absolute : DCommon.ComputedTypeError<`Impossible to cast on AbsolutePath because value ${GenericInput} is not absolute path.`> : never;
+    segment: DCommon.IsExtends<GenericOutput, DPath.Segment> extends true ? DPath.IsLiteralSegmentPath<GenericInput> extends true ? DPath.Segment : DCommon.ComputedTypeError<`Impossible to cast on SegmentPath because value ${GenericInput} is not segment path.`> : never;
 }

package/dist/dataStructure/constraint/defaults/index.d.ts

@@ -23,6 +23,7 @@ export * from './path';
 export * from './positive';
 export * from './refine';
 export * from './safe';
+export * from './segmentPath';
 export * from './strictNegative';
 export * from './strictPositive';
 export * from './stringLengthEqual';

package/dist/dataStructure/constraint/defaults/segmentPath.cjs

@@ -0,0 +1,13 @@
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+const require_isSegment = require("../../../path/isSegment.cjs");
+//#region scripts/dataStructure/constraint/defaults/segmentPath.ts
+const segmentPathConstraintKind = require_kind.createKind("segment-path-constraint");
+const SegmentPathConstraint = require_base.createConstraint(segmentPathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => require_isSegment.isSegment(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.SegmentPathConstraint = SegmentPathConstraint;
+exports.segmentPathConstraintKind = segmentPathConstraintKind;

package/dist/dataStructure/constraint/defaults/segmentPath.d.ts

@@ -0,0 +1,10 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DPath from '../../../path';
+export declare const segmentPathConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/segment-path-constraint", unknown>>;
+export interface SegmentPathConstraintDefinition extends ConstraintDefinition {
+}
+export interface SegmentPathConstraint extends DCommon.Forward<Constraint<string, string & DPath.Segment, SegmentPathConstraintDefinition> & DKind.Kind<typeof segmentPathConstraintKind>> {
+}
+export declare const SegmentPathConstraint: () => SegmentPathConstraint;

package/dist/dataStructure/constraint/defaults/segmentPath.mjs

@@ -0,0 +1,12 @@
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+import { isSegment } from "../../../path/isSegment.mjs";
+//#region scripts/dataStructure/constraint/defaults/segmentPath.ts
+const segmentPathConstraintKind = createKind("segment-path-constraint");
+const SegmentPathConstraint = createConstraint(segmentPathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => isSegment(data) ? SuccessSymbol : ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { SegmentPathConstraint, segmentPathConstraintKind };

package/dist/dataStructure/constraint/types/constraints.d.ts

@@ -1,7 +1,6 @@
 import { Constraint } from '../base';
 import type * as DDefaults from "../defaults";
 export interface ConstraintsStore {
-    absolutePath: DDefaults.AbsolutePathConstraint;
     allowedCharacters: DDefaults.AllowedCharactersConstraint;
     email: DDefaults.EmailConstraint;
     url: DDefaults.UrlConstraint;
@@ -31,7 +30,9 @@ export interface ConstraintsStore {
     greaterThanOrEqual: DDefaults.GreaterThanOrEqualConstraint;
     lessThan: DDefaults.LessThanConstraint;
     lessThanOrEqual: DDefaults.LessThanOrEqualConstraint;
+    absolutePath: DDefaults.AbsolutePathConstraint;
     path: DDefaults.PathConstraint;
+    segmentPath: DDefaults.SegmentPathConstraint;
     refine: DDefaults.RefineConstraint;
 }
 export type Constraints = Extract<ConstraintsStore[keyof ConstraintsStore], Constraint>;

package/dist/dataStructure/helpers/index.d.ts

@@ -40,6 +40,7 @@ export * from './record';
 export * from './refine';
 export * from './required';
 export * from './safe';
+export * from './segmentPath';
 export * from './string';
 export * from './strictNegative';
 export * from './strictPositive';

package/dist/dataStructure/helpers/segmentPath.cjs

@@ -0,0 +1,7 @@
+const require_segmentPath = require("../constraint/defaults/segmentPath.cjs");
+//#region scripts/dataStructure/helpers/segmentPath.ts
+function segmentPath() {
+	return require_segmentPath.SegmentPathConstraint();
+}
+//#endregion
+exports.segmentPath = segmentPath;

package/dist/dataStructure/helpers/segmentPath.d.ts

@@ -0,0 +1,2 @@
+import { SegmentPathConstraint } from '../constraint';
+export declare function segmentPath(): SegmentPathConstraint;

package/dist/dataStructure/helpers/segmentPath.mjs

@@ -0,0 +1,7 @@
+import { SegmentPathConstraint } from "../constraint/defaults/segmentPath.mjs";
+//#region scripts/dataStructure/helpers/segmentPath.ts
+function segmentPath() {
+	return SegmentPathConstraint();
+}
+//#endregion
+export { segmentPath };

package/dist/dataStructure/index.cjs

@@ -30,6 +30,7 @@ const require_path = require("./constraint/defaults/path.cjs");
 const require_positive = require("./constraint/defaults/positive.cjs");
 const require_refine = require("./constraint/defaults/refine.cjs");
 const require_safe = require("./constraint/defaults/safe.cjs");
+const require_segmentPath = require("./constraint/defaults/segmentPath.cjs");
 const require_strictNegative = require("./constraint/defaults/strictNegative.cjs");
 const require_strictPositive = require("./constraint/defaults/strictPositive.cjs");
 const require_stringLengthEqual = require("./constraint/defaults/stringLengthEqual.cjs");
@@ -115,6 +116,7 @@ const require_record$1 = require("./helpers/record.cjs");
 const require_refine$1 = require("./helpers/refine.cjs");
 const require_required = require("./helpers/required.cjs");
 const require_safe$1 = require("./helpers/safe.cjs");
+const require_segmentPath$1 = require("./helpers/segmentPath.cjs");
 const require_string$2 = require("./helpers/string.cjs");
 const require_strictNegative$1 = require("./helpers/strictNegative.cjs");
 const require_strictPositive$1 = require("./helpers/strictPositive.cjs");
@@ -166,6 +168,7 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	RefineConstraint: () => require_refine.RefineConstraint,
 	RegexConstraint: () => require_regex.RegexConstraint,
 	SafeConstraint: () => require_safe.SafeConstraint,
+	SegmentPathConstraint: () => require_segmentPath.SegmentPathConstraint,
 	StrictNegativeConstraint: () => require_strictNegative.StrictNegativeConstraint,
 	StrictPositiveConstraint: () => require_strictPositive.StrictPositiveConstraint,
 	StringLengthEqualConstraint: () => require_stringLengthEqual.StringLengthEqualConstraint,
@@ -294,6 +297,8 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	required: () => require_required.required,
 	safe: () => require_safe$1.safe,
 	safeConstraintKind: () => require_safe.safeConstraintKind,
+	segmentPath: () => require_segmentPath$1.segmentPath,
+	segmentPathConstraintKind: () => require_segmentPath.segmentPathConstraintKind,
 	strictNegative: () => require_strictNegative$1.strictNegative,
 	strictNegativeConstraintKind: () => require_strictNegative.strictNegativeConstraintKind,
 	strictPositive: () => require_strictPositive$1.strictPositive,
@@ -365,6 +370,7 @@ exports.RecordStructure = require_record.RecordStructure;
 exports.RefineConstraint = require_refine.RefineConstraint;
 exports.RegexConstraint = require_regex.RegexConstraint;
 exports.SafeConstraint = require_safe.SafeConstraint;
+exports.SegmentPathConstraint = require_segmentPath.SegmentPathConstraint;
 exports.StrictNegativeConstraint = require_strictNegative.StrictNegativeConstraint;
 exports.StrictPositiveConstraint = require_strictPositive.StrictPositiveConstraint;
 exports.StringLengthEqualConstraint = require_stringLengthEqual.StringLengthEqualConstraint;
@@ -499,6 +505,8 @@ exports.regexConstraintKind = require_regex.regexConstraintKind;
 exports.required = require_required.required;
 exports.safe = require_safe$1.safe;
 exports.safeConstraintKind = require_safe.safeConstraintKind;
+exports.segmentPath = require_segmentPath$1.segmentPath;
+exports.segmentPathConstraintKind = require_segmentPath.segmentPathConstraintKind;
 exports.strictNegative = require_strictNegative$1.strictNegative;
 exports.strictNegativeConstraintKind = require_strictNegative.strictNegativeConstraintKind;
 exports.strictPositive = require_strictPositive$1.strictPositive;

package/dist/dataStructure/index.mjs

@@ -30,6 +30,7 @@ import { PathConstraint, pathConstraintKind } from "./constraint/defaults/path.m
 import { PositiveConstraint, positiveConstraintKind } from "./constraint/defaults/positive.mjs";
 import { RefineConstraint, refineConstraintKind } from "./constraint/defaults/refine.mjs";
 import { SafeConstraint, safeConstraintKind } from "./constraint/defaults/safe.mjs";
+import { SegmentPathConstraint, segmentPathConstraintKind } from "./constraint/defaults/segmentPath.mjs";
 import { StrictNegativeConstraint, strictNegativeConstraintKind } from "./constraint/defaults/strictNegative.mjs";
 import { StrictPositiveConstraint, strictPositiveConstraintKind } from "./constraint/defaults/strictPositive.mjs";
 import { StringLengthEqualConstraint, stringLengthEqualConstraintKind } from "./constraint/defaults/stringLengthEqual.mjs";
@@ -115,6 +116,7 @@ import { record } from "./helpers/record.mjs";
 import { refine } from "./helpers/refine.mjs";
 import { required } from "./helpers/required.mjs";
 import { safe } from "./helpers/safe.mjs";
+import { segmentPath } from "./helpers/segmentPath.mjs";
 import { string } from "./helpers/string.mjs";
 import { strictNegative } from "./helpers/strictNegative.mjs";
 import { strictPositive } from "./helpers/strictPositive.mjs";
@@ -166,6 +168,7 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	RefineConstraint: () => RefineConstraint,
 	RegexConstraint: () => RegexConstraint,
 	SafeConstraint: () => SafeConstraint,
+	SegmentPathConstraint: () => SegmentPathConstraint,
 	StrictNegativeConstraint: () => StrictNegativeConstraint,
 	StrictPositiveConstraint: () => StrictPositiveConstraint,
 	StringLengthEqualConstraint: () => StringLengthEqualConstraint,
@@ -294,6 +297,8 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	required: () => required,
 	safe: () => safe,
 	safeConstraintKind: () => safeConstraintKind,
+	segmentPath: () => segmentPath,
+	segmentPathConstraintKind: () => segmentPathConstraintKind,
 	strictNegative: () => strictNegative,
 	strictNegativeConstraintKind: () => strictNegativeConstraintKind,
 	strictPositive: () => strictPositive,
@@ -325,4 +330,4 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	uuidConstraintKind: () => uuidConstraintKind
 });
 //#endregion
-export { AbsolutePathConstraint, AllowedCharactersConstraint, ArrayLengthEqualConstraint, ArrayStructure, BetweenThanConstraint, BetweenThanOrEqualConstraint, BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, DateType, EmailConstraint, ErrorSymbol, EvenConstraint, GreaterThanConstraint, GreaterThanOrEqualConstraint, IntegerConstraint, LazyStructure, LessThanConstraint, LessThanOrEqualConstraint, MaxCharactersConstraint, MaxElementsConstraint, MinCharactersConstraint, MinElementsConstraint, MultipleOfConstraint, NegativeConstraint, NonEncodableStringStructure, NotEmptyConstraint, NotZeroConstraint, NullType, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PathConstraint, PositiveConstraint, RecordStructure, RefineConstraint, RegexConstraint, SafeConstraint, StrictNegativeConstraint, StrictPositiveConstraint, StringLengthEqualConstraint, StringLiteralType, StringType, StructureClass, SuccessSymbol, TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined, TimeType, TrimmedConstraint, TypeStructure, UndefinedType, UnionStructure, UrlConstraint, UuidConstraint, absolutePath, absolutePathConstraintKind, allowedCharacters, allowedCharactersConstraintKind, array, arrayLengthEqual, arrayLengthEqualConstraintKind, arrayStructureKind, betweenThan, betweenThanConstraintKind, betweenThanOrEqual, betweenThanOrEqualConstraintKind, bigint, bigintFundamentalTypeKind, bigintLiteralTypeKind, bigintTypeKind, boolean, booleanFundamentalTypeKind, booleanLiteralTypeKind, booleanTypeKind, codecKind, codecsKind, constraintIdentifier, constraintKind, createCodec, createCodecs, createConstraint, createErrorHandler, createErrorInterpreter, createFundamentalType, createGetErrorHandler, createKind, createStructure, createType, dataStructure_exports, date, dateFundamentalTypeKind, dateTypeKind, decodeIssueKind, email, emailConstraintKind, encodeIssueKind, even, evenConstraintKind, extend, fundamentalTypeIdentifier, fundamentalTypeKind, greaterThan, greaterThanConstraintKind, greaterThanOrEqual, greaterThanOrEqualConstraintKind, integer, integerConstraintKind, isNullStructure, isUndefinedStructure, issueKind, lazy, lazyStructureKind, lessThan, lessThanConstraintKind, lessThanOrEqual, lessThanOrEqualConstraintKind, literal, maxCharacters, maxCharactersConstraintKind, maxElements, maxElementsConstraintKind, minCharacters, minCharactersConstraintKind, minElements, minElementsConstraintKind, multipleOf, multipleOfConstraintKind, negative, negativeConstraintKind, nonEncodableStringStructureKind, notEmpty, notEmptyConstraintKind, notZero, notZeroConstraintKind, nullHelper as null, nullFundamentalTypeKind, nullTypeKind, nullable, number, numberFundamentalTypeKind, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, path, pathConstraintKind, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, regex, regexConstraintKind, required, safe, safeConstraintKind, strictNegative, strictNegativeConstraintKind, strictPositive, strictPositiveConstraintKind, string, stringFundamentalTypeKind, stringLengthEqual, stringLengthEqualConstraintKind, stringLiteralTypeKind, stringTypeKind, structureIdentifier, structureKind, time, timeFundamentalTypeKind, timeTypeKind, trimmed, trimmedConstraintKind, typeIdentifier, typeKind, typeStructureKind, undefinedHelper as undefined, undefinedFundamentalTypeKind, undefinedTypeKind, union, unionStructureKind, url, urlConstraintKind, uuid, uuidConstraintKind };
+export { AbsolutePathConstraint, AllowedCharactersConstraint, ArrayLengthEqualConstraint, ArrayStructure, BetweenThanConstraint, BetweenThanOrEqualConstraint, BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, DateType, EmailConstraint, ErrorSymbol, EvenConstraint, GreaterThanConstraint, GreaterThanOrEqualConstraint, IntegerConstraint, LazyStructure, LessThanConstraint, LessThanOrEqualConstraint, MaxCharactersConstraint, MaxElementsConstraint, MinCharactersConstraint, MinElementsConstraint, MultipleOfConstraint, NegativeConstraint, NonEncodableStringStructure, NotEmptyConstraint, NotZeroConstraint, NullType, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PathConstraint, PositiveConstraint, RecordStructure, RefineConstraint, RegexConstraint, SafeConstraint, SegmentPathConstraint, StrictNegativeConstraint, StrictPositiveConstraint, StringLengthEqualConstraint, StringLiteralType, StringType, StructureClass, SuccessSymbol, TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined, TimeType, TrimmedConstraint, TypeStructure, UndefinedType, UnionStructure, UrlConstraint, UuidConstraint, absolutePath, absolutePathConstraintKind, allowedCharacters, allowedCharactersConstraintKind, array, arrayLengthEqual, arrayLengthEqualConstraintKind, arrayStructureKind, betweenThan, betweenThanConstraintKind, betweenThanOrEqual, betweenThanOrEqualConstraintKind, bigint, bigintFundamentalTypeKind, bigintLiteralTypeKind, bigintTypeKind, boolean, booleanFundamentalTypeKind, booleanLiteralTypeKind, booleanTypeKind, codecKind, codecsKind, constraintIdentifier, constraintKind, createCodec, createCodecs, createConstraint, createErrorHandler, createErrorInterpreter, createFundamentalType, createGetErrorHandler, createKind, createStructure, createType, dataStructure_exports, date, dateFundamentalTypeKind, dateTypeKind, decodeIssueKind, email, emailConstraintKind, encodeIssueKind, even, evenConstraintKind, extend, fundamentalTypeIdentifier, fundamentalTypeKind, greaterThan, greaterThanConstraintKind, greaterThanOrEqual, greaterThanOrEqualConstraintKind, integer, integerConstraintKind, isNullStructure, isUndefinedStructure, issueKind, lazy, lazyStructureKind, lessThan, lessThanConstraintKind, lessThanOrEqual, lessThanOrEqualConstraintKind, literal, maxCharacters, maxCharactersConstraintKind, maxElements, maxElementsConstraintKind, minCharacters, minCharactersConstraintKind, minElements, minElementsConstraintKind, multipleOf, multipleOfConstraintKind, negative, negativeConstraintKind, nonEncodableStringStructureKind, notEmpty, notEmptyConstraintKind, notZero, notZeroConstraintKind, nullHelper as null, nullFundamentalTypeKind, nullTypeKind, nullable, number, numberFundamentalTypeKind, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, path, pathConstraintKind, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, regex, regexConstraintKind, required, safe, safeConstraintKind, segmentPath, segmentPathConstraintKind, strictNegative, strictNegativeConstraintKind, strictPositive, strictPositiveConstraintKind, string, stringFundamentalTypeKind, stringLengthEqual, stringLengthEqualConstraintKind, stringLiteralTypeKind, stringTypeKind, structureIdentifier, structureKind, time, timeFundamentalTypeKind, timeTypeKind, trimmed, trimmedConstraintKind, typeIdentifier, typeKind, typeStructureKind, undefinedHelper as undefined, undefinedFundamentalTypeKind, undefinedTypeKind, union, unionStructureKind, url, urlConstraintKind, uuid, uuidConstraintKind };

package/dist/modeling/entity/namespace.cjs

@@ -7,7 +7,7 @@ const namespaceKind = require_kind.createKind("namespace");
 function createEntityNamespace(entityName) {
 	return {
 		name: entityName,
-		createNewType: (name, structure, newTypeConstraints = []) => require_helper$1.createNewEntity(`${entityName}${name}`, structure, newTypeConstraints),
+		createNewType: (name, structure, newTypeConstraints = []) => require_helper$1.createNewType(`${entityName}${name}`, structure, newTypeConstraints),
 		createEntity: (shape) => require_helper.createEntity(entityName, shape),
 		createFlag: (entityStructure, name, valueStructure) => require_base.createFlag(entityStructure, `${entityName}${name}`, valueStructure),
 		[namespaceKind.runTimeKey]: null

package/dist/modeling/entity/namespace.mjs

@@ -1,13 +1,13 @@
 import { createKind } from "../kind.mjs";
 import { createEntity } from "./helper.mjs";
-import { createNewEntity } from "../newType/helper.mjs";
+import { createNewType } from "../newType/helper.mjs";
 import { createFlag } from "../flag/base.mjs";
 //#region scripts/modeling/entity/namespace.ts
 const namespaceKind = createKind("namespace");
 function createEntityNamespace(entityName) {
 	return {
 		name: entityName,
-		createNewType: (name, structure, newTypeConstraints = []) => createNewEntity(`${entityName}${name}`, structure, newTypeConstraints),
+		createNewType: (name, structure, newTypeConstraints = []) => createNewType(`${entityName}${name}`, structure, newTypeConstraints),
 		createEntity: (shape) => createEntity(entityName, shape),
 		createFlag: (entityStructure, name, valueStructure) => createFlag(entityStructure, `${entityName}${name}`, valueStructure),
 		[namespaceKind.runTimeKey]: null

package/dist/modeling/index.cjs

@@ -17,7 +17,7 @@ var modeling_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	createEntityNamespace: () => require_namespace.createEntityNamespace,
 	createFlag: () => require_base$2.createFlag,
 	createKind: () => require_kind.createKind,
-	createNewEntity: () => require_helper$1.createNewEntity,
+	createNewType: () => require_helper$1.createNewType,
 	createTaggedObject: () => require_helper$2.createTaggedObject,
 	entityKind: () => require_base.entityKind,
 	entityStructureKind: () => require_base.entityStructureKind,
@@ -38,7 +38,7 @@ exports.createEntity = require_helper.createEntity;
 exports.createEntityNamespace = require_namespace.createEntityNamespace;
 exports.createFlag = require_base$2.createFlag;
 exports.createKind = require_kind.createKind;
-exports.createNewEntity = require_helper$1.createNewEntity;
+exports.createNewType = require_helper$1.createNewType;
 exports.createTaggedObject = require_helper$2.createTaggedObject;
 exports.entityKind = require_base.entityKind;
 exports.entityStructureKind = require_base.entityStructureKind;

package/dist/modeling/index.mjs

@@ -3,7 +3,7 @@ import { createKind } from "./kind.mjs";
 import { EntityStructure, entityKind, entityStructureKind } from "./entity/base.mjs";
 import { createEntity } from "./entity/helper.mjs";
 import { NewTypeStructure, newTypeStructureKind } from "./newType/base.mjs";
-import { createNewEntity } from "./newType/helper.mjs";
+import { createNewType } from "./newType/helper.mjs";
 import { createFlag, flagKind } from "./flag/base.mjs";
 import { createEntityNamespace, namespaceKind } from "./entity/namespace.mjs";
 import { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind } from "./taggedObject/base.mjs";
@@ -17,7 +17,7 @@ var modeling_exports = /* @__PURE__ */ __exportAll({
 	createEntityNamespace: () => createEntityNamespace,
 	createFlag: () => createFlag,
 	createKind: () => createKind,
-	createNewEntity: () => createNewEntity,
+	createNewType: () => createNewType,
 	createTaggedObject: () => createTaggedObject,
 	entityKind: () => entityKind,
 	entityStructureKind: () => entityStructureKind,
@@ -31,4 +31,4 @@ var modeling_exports = /* @__PURE__ */ __exportAll({
 	taggedObjectStructureKind: () => taggedObjectStructureKind
 });
 //#endregion
-export { EntityStructure, NewTypeStructure, TaggedObjectStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewEntity, createTaggedObject, entityKind, entityStructureKind, flagKind, getTagValue, hasTagValue, modeling_exports, namespaceKind, newTypeStructureKind, objectTagKind, taggedObject, taggedObjectStructureKind };
+export { EntityStructure, NewTypeStructure, TaggedObjectStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewType, createTaggedObject, entityKind, entityStructureKind, flagKind, getTagValue, hasTagValue, modeling_exports, namespaceKind, newTypeStructureKind, objectTagKind, taggedObject, taggedObjectStructureKind };

package/dist/modeling/newType/helper.cjs

@@ -1,7 +1,7 @@
 const require_base = require("./base.cjs");
 //#region scripts/modeling/newType/helper.ts
-function createNewEntity(name, structure, newTypeConstraints = []) {
+function createNewType(name, structure, newTypeConstraints = []) {
 	return require_base.NewTypeStructure(name, structure, newTypeConstraints);
 }
 //#endregion
-exports.createNewEntity = createNewEntity;
+exports.createNewType = createNewType;

package/dist/modeling/newType/helper.d.ts

@@ -2,4 +2,4 @@ import { NewType, NewTypeStructure } from './base';
 import type * as DCommon from '../../common';
 import type * as DDataStructure from '../../dataStructure';
 export type ForbiddenTopLevelNewType<GenericValue extends unknown> = GenericValue extends NewType ? DCommon.ComputedTypeError<"NewType on top level of NewType declaration is forbidden."> : never;
-export declare function createNewEntity<GenericName extends Capitalize<string>, GenericStructure extends DDataStructure.Structure, const GenericNewTypeConstraint extends readonly DDataStructure.Constraint<DDataStructure.StructureValue<GenericStructure>>[] = readonly []>(name: (GenericName & DCommon.NeverCoalescing<ForbiddenTopLevelNewType<DDataStructure.StructureValue<GenericStructure>>, unknown>), structure: GenericStructure, newTypeConstraints?: GenericNewTypeConstraint): NewTypeStructure<GenericName & DCommon.NeverCoalescing<ForbiddenTopLevelNewType<DDataStructure.StructureValue<GenericStructure>>, unknown>, DDataStructure.StructureValue<GenericStructure>, GenericNewTypeConstraint>;
+export declare function createNewType<GenericName extends Capitalize<string>, GenericStructure extends DDataStructure.Structure, const GenericNewTypeConstraint extends readonly DDataStructure.Constraint<DDataStructure.StructureValue<GenericStructure>>[] = readonly []>(name: (GenericName & DCommon.NeverCoalescing<ForbiddenTopLevelNewType<DDataStructure.StructureValue<GenericStructure>>, unknown>), structure: GenericStructure, newTypeConstraints?: GenericNewTypeConstraint): NewTypeStructure<GenericName & DCommon.NeverCoalescing<ForbiddenTopLevelNewType<DDataStructure.StructureValue<GenericStructure>>, unknown>, DDataStructure.StructureValue<GenericStructure>, GenericNewTypeConstraint>;

package/dist/modeling/newType/helper.mjs

@@ -1,7 +1,7 @@
 import { NewTypeStructure } from "./base.mjs";
 //#region scripts/modeling/newType/helper.ts
-function createNewEntity(name, structure, newTypeConstraints = []) {
+function createNewType(name, structure, newTypeConstraints = []) {
 	return NewTypeStructure(name, structure, newTypeConstraints);
 }
 //#endregion
-export { createNewEntity };
+export { createNewType };

package/dist/modeling/taggedObject/helper.cjs

@@ -19,8 +19,13 @@ function taggedObject(tag, props) {
 		[require_base.objectTagKind.runTimeKey]: tag
 	};
 }
-function createTaggedObject(name) {
-	return (shape) => require_base.TaggedObjectStructure(name, shape);
+function createTaggedObject(...args) {
+	if (args.length === 1) {
+		const [name] = args;
+		return (shape) => createTaggedObject(name, shape);
+	}
+	const [name, shape] = args;
+	return require_base.TaggedObjectStructure(name, shape);
 }
 //#endregion
 exports.createTaggedObject = createTaggedObject;

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

@@ -12,3 +12,4 @@ export declare function taggedObject<GenericTaggedObject extends ObjectTag>(...a
 ] : never): GenericTaggedObject;
 export type RequireTaggedObjectSameShape<GenericTaggedObject extends ObjectTag, GenericTaggedObjectShape extends ShapeTaggedObjectStructure> = DCommon.IsEqual<DCommon.SimplifyTopLevel<DObject.DeepReadonly<DKind.Remove<GenericTaggedObject>>>, DCommon.SimplifyTopLevel<DObject.DeepReadonly<DDataStructure.ShapeObjectStructureValue<GenericTaggedObjectShape>>>> extends true ? unknown : DCommon.ComputedTypeError<"Shape do not match.">;
 export declare function createTaggedObject<GenericTaggedObject extends ObjectTag>(name: GetTagValue<GenericTaggedObject>): <GenericShape extends ShapeTaggedObjectStructure<GenericTaggedObject>>(shape: (GenericShape & RequireTaggedObjectSameShape<GenericTaggedObject, GenericShape>)) => TaggedObjectStructure<GenericTaggedObject>;
+export declare function createTaggedObject<GenericTaggedObject extends ObjectTag, GenericName extends string = never, GenericShape extends DDataStructure.ShapeObjectStructure = never>(name: GetTagValue<GenericTaggedObject> | GenericName, shape: ShapeTaggedObjectStructure<GenericTaggedObject> | GenericShape): TaggedObjectStructure<ObjectTag extends GenericTaggedObject ? (ObjectTag<GenericName> & DDataStructure.ShapeObjectStructureValue<GenericShape>) : GenericTaggedObject>;

package/dist/modeling/taggedObject/helper.mjs

@@ -19,8 +19,13 @@ function taggedObject(tag, props) {
 		[objectTagKind.runTimeKey]: tag
 	};
 }
-function createTaggedObject(name) {
-	return (shape) => TaggedObjectStructure(name, shape);
+function createTaggedObject(...args) {
+	if (args.length === 1) {
+		const [name] = args;
+		return (shape) => createTaggedObject(name, shape);
+	}
+	const [name, shape] = args;
+	return TaggedObjectStructure(name, shape);
 }
 //#endregion
 export { createTaggedObject, getTagValue, hasTagValue, taggedObject };

package/dist/path/constraints/index.d.ts

@@ -1,2 +1,3 @@
-export type * from './path';
 export type * from './absolute';
+export type * from './path';
+export type * from './segment';

package/dist/path/constraints/segment.d.ts

@@ -0,0 +1,3 @@
+import type * as DCommon from '../../common';
+export interface Segment extends DCommon.Constraint<"path-segment"> {
+}

package/dist/path/getBaseName.cjs

@@ -1,10 +1,12 @@
+const require_isSegment = require("./isSegment.cjs");
 //#region scripts/path/getBaseName.ts
 const baseNameRegex = /([^/]+)$/;
 const extensionNameRegex = /(?<!^)\.[^./]+$/;
 function getBaseName(path, params) {
 	const baseName = baseNameRegex.exec(path)?.[1];
 	if (baseName === void 0) return null;
-	return params?.removeExtension ? baseName.replace(extensionNameRegex, "") : baseName;
+	const result = params?.removeExtension ? baseName.replace(extensionNameRegex, "") : baseName;
+	return require_isSegment.isSegment(result) ? result : null;
 }
 //#endregion
 exports.getBaseName = getBaseName;

package/dist/path/getBaseName.d.ts

@@ -1,5 +1,5 @@
-import { Absolute, Path } from './constraints';
+import { Absolute, Path, Segment } from './constraints';
 export interface GetBaseNameParams {
     removeExtension?: boolean;
 }
-export declare function getBaseName<GenericPath extends string & (Path | Absolute)>(path: GenericPath, params?: GetBaseNameParams): string | null;
+export declare function getBaseName<GenericPath extends string & (Path | Absolute | Segment)>(path: GenericPath, params?: GetBaseNameParams): (string & Segment) | null;

package/dist/path/getBaseName.mjs

@@ -1,10 +1,12 @@
+import { isSegment } from "./isSegment.mjs";
 //#region scripts/path/getBaseName.ts
 const baseNameRegex = /([^/]+)$/;
 const extensionNameRegex = /(?<!^)\.[^./]+$/;
 function getBaseName(path, params) {
 	const baseName = baseNameRegex.exec(path)?.[1];
 	if (baseName === void 0) return null;
-	return params?.removeExtension ? baseName.replace(extensionNameRegex, "") : baseName;
+	const result = params?.removeExtension ? baseName.replace(extensionNameRegex, "") : baseName;
+	return isSegment(result) ? result : null;
 }
 //#endregion
 export { getBaseName };

package/dist/path/getExtensionName.cjs

@@ -1,3 +1,4 @@
+const require_isSegment = require("./isSegment.cjs");
 //#region scripts/path/getExtensionName.ts
 const basenameRegex = /([^/]+)$/;
 function getExtensionName(path, params) {
@@ -6,7 +7,8 @@ function getExtensionName(path, params) {
 	const dotIndex = baseName.lastIndexOf(".");
 	if (dotIndex <= 0 || dotIndex === baseName.length - 1) return null;
 	const extension = baseName.slice(dotIndex + 1);
-	return params?.withDot ? `.${extension}` : extension;
+	const result = params?.withDot ? `.${extension}` : extension;
+	return require_isSegment.isSegment(result) ? result : null;
 }
 //#endregion
 exports.getExtensionName = getExtensionName;

package/dist/path/getExtensionName.d.ts

@@ -1,5 +1,5 @@
-import { Absolute, Path } from './constraints';
+import { Absolute, Path, Segment } from './constraints';
 export interface GetExtensionNameParams {
     withDot?: boolean;
 }
-export declare function getExtensionName<GenericPath extends string & (Path | Absolute)>(path: GenericPath, params?: GetExtensionNameParams): string | null;
+export declare function getExtensionName<GenericPath extends string & (Path | Absolute | Segment)>(path: GenericPath, params?: GetExtensionNameParams): (string & Segment) | null;

package/dist/path/getExtensionName.mjs

@@ -1,3 +1,4 @@
+import { isSegment } from "./isSegment.mjs";
 //#region scripts/path/getExtensionName.ts
 const basenameRegex = /([^/]+)$/;
 function getExtensionName(path, params) {
@@ -6,7 +7,8 @@ function getExtensionName(path, params) {
 	const dotIndex = baseName.lastIndexOf(".");
 	if (dotIndex <= 0 || dotIndex === baseName.length - 1) return null;
 	const extension = baseName.slice(dotIndex + 1);
-	return params?.withDot ? `.${extension}` : extension;
+	const result = params?.withDot ? `.${extension}` : extension;
+	return isSegment(result) ? result : null;
 }
 //#endregion
 export { getExtensionName };

package/dist/path/index.cjs

@@ -1,5 +1,6 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_computeRelative = require("./computeRelative.cjs");
+const require_isSegment = require("./isSegment.cjs");
 const require_getBaseName = require("./getBaseName.cjs");
 const require_getExtensionName = require("./getExtensionName.cjs");
 const require_getParentFolderPath = require("./getParentFolderPath.cjs");
@@ -16,6 +17,7 @@ var path_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	getParentFolderPath: () => require_getParentFolderPath.getParentFolderPath,
 	is: () => require_is.is,
 	isAbsolute: () => require_isAbsolute.isAbsolute,
+	isSegment: () => require_isSegment.isSegment,
 	normalize: () => require_normalize.normalize,
 	resolveFrom: () => require_resolveFrom.resolveFrom,
 	resolveRelative: () => require_resolveRelative.resolveRelative
@@ -27,6 +29,7 @@ exports.getExtensionName = require_getExtensionName.getExtensionName;
 exports.getParentFolderPath = require_getParentFolderPath.getParentFolderPath;
 exports.is = require_is.is;
 exports.isAbsolute = require_isAbsolute.isAbsolute;
+exports.isSegment = require_isSegment.isSegment;
 exports.normalize = require_normalize.normalize;
 Object.defineProperty(exports, "path_exports", {
 	enumerable: true,

package/dist/path/index.d.ts

@@ -5,6 +5,7 @@ export * from './getExtensionName';
 export * from './getParentFolderPath';
 export * from './is';
 export * from './isAbsolute';
+export * from './isSegment';
 export * from './normalize';
 export * from './resolveFrom';
 export * from './resolveRelative';

package/dist/path/index.mjs

@@ -1,5 +1,6 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { computeRelative } from "./computeRelative.mjs";
+import { isSegment } from "./isSegment.mjs";
 import { getBaseName } from "./getBaseName.mjs";
 import { getExtensionName } from "./getExtensionName.mjs";
 import { getParentFolderPath } from "./getParentFolderPath.mjs";
@@ -16,9 +17,10 @@ var path_exports = /* @__PURE__ */ __exportAll({
 	getParentFolderPath: () => getParentFolderPath,
 	is: () => is,
 	isAbsolute: () => isAbsolute,
+	isSegment: () => isSegment,
 	normalize: () => normalize,
 	resolveFrom: () => resolveFrom,
 	resolveRelative: () => resolveRelative
 });
 //#endregion
-export { computeRelative, getBaseName, getExtensionName, getParentFolderPath, is, isAbsolute, normalize, path_exports, resolveFrom, resolveRelative };
+export { computeRelative, getBaseName, getExtensionName, getParentFolderPath, is, isAbsolute, isSegment, normalize, path_exports, resolveFrom, resolveRelative };

package/dist/path/isSegment.cjs

@@ -0,0 +1,6 @@
+//#region scripts/path/isSegment.ts
+function isSegment(value) {
+	return value !== "" && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\0");
+}
+//#endregion
+exports.isSegment = isSegment;

package/dist/path/isSegment.d.ts

@@ -0,0 +1,4 @@
+import { Segment } from './constraints';
+import { IsLiteralSegmentPath } from './types';
+import type * as DString from '../string';
+export declare function isSegment<GenericValue extends string>(value: GenericValue): value is (GenericValue extends Segment ? GenericValue : IsLiteralSegmentPath<GenericValue> extends true ? GenericValue : DString.IsLiteral<GenericValue> extends true ? never : GenericValue & Segment);

package/dist/path/isSegment.mjs

@@ -0,0 +1,6 @@
+//#region scripts/path/isSegment.ts
+function isSegment(value) {
+	return value !== "" && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\0");
+}
+//#endregion
+export { isSegment };

package/dist/path/resolveFrom.d.ts

@@ -1,10 +1,10 @@
-import { Absolute, Path } from './constraints';
+import { Absolute, Path, Segment } from './constraints';
 import { RequireSegments } from './types';
 import type * as DCommon from '../common';
 export interface ResolveFromParams {
     stayInOrigin?: boolean;
 }
-export declare function resolveFrom<const GenericSegments extends readonly (string & (Path | Absolute))[], const GenericParams extends ResolveFromParams>(origin: string & Absolute, segments: GenericSegments & RequireSegments<GenericSegments>, params?: GenericParams): (string & Absolute) | (DCommon.BreakGenericLink<DCommon.Or<[
+export declare function resolveFrom<const GenericSegments extends readonly (string & (Path | Absolute | Segment))[], const GenericParams extends ResolveFromParams>(origin: string & Absolute, segments: GenericSegments & RequireSegments<GenericSegments>, params?: GenericParams): (string & Absolute) | (DCommon.BreakGenericLink<DCommon.Or<[
     DCommon.IsEqual<GenericParams["stayInOrigin"], ResolveFromParams["stayInOrigin"]>,
     DCommon.IsEqual<GenericParams["stayInOrigin"], false>,
     DCommon.IsEqual<GenericParams["stayInOrigin"], unknown>

package/dist/path/resolveRelative.d.ts

@@ -1,10 +1,10 @@
-import { Absolute, Path } from './constraints';
+import { Absolute, Path, Segment } from './constraints';
 import { RequireSegments } from './types';
 import type * as DCommon from '../common';
-type HasAbsolutePath<GenericSegments extends readonly (string & (Path | Absolute))[]> = DCommon.ContainExtends<{
+type HasAbsolutePath<GenericSegments extends readonly (string & (Path | Absolute | Segment))[]> = DCommon.ContainExtends<{
     [Prop in keyof GenericSegments]: [DCommon.IsExtends<GenericSegments[Prop], Absolute>];
 }[Extract<keyof GenericSegments, number>], [
     true
 ]>;
-export declare function resolveRelative<const GenericSegments extends readonly (string & (Path | Absolute))[]>(segments: GenericSegments & RequireSegments<GenericSegments>): string & Path & (DCommon.BreakGenericLink<HasAbsolutePath<GenericSegments> extends true ? Absolute : unknown>);
+export declare function resolveRelative<const GenericSegments extends readonly (string & (Path | Absolute | Segment))[]>(segments: GenericSegments & RequireSegments<GenericSegments>): string & Path & (DCommon.BreakGenericLink<HasAbsolutePath<GenericSegments> extends true ? Absolute : unknown>);
 export {};

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

@@ -1,5 +1,7 @@
 export type * from './isLiteralAbsolutePath';
 export type * from './isLiteralPath';
+export type * from './isLiteralSegmentPath';
 export type * from './requireLiteralAbsolutePath';
 export type * from './requireLiteralPath';
+export type * from './requireLiteralSegmentPath';
 export type * from './requireSegments';

package/dist/path/types/isLiteralSegmentPath.d.ts

@@ -0,0 +1,9 @@
+import type * as DCommon from '../../common';
+import type * as DString from '../../string';
+export type IsLiteralSegmentPath<GenericValue extends string> = DString.IsLiteral<GenericValue> extends true ? DCommon.Not<DCommon.Or<[
+    DCommon.IsEqual<GenericValue, ".">,
+    DCommon.IsEqual<GenericValue, "..">,
+    DCommon.IsEqual<GenericValue, "">,
+    DString.Includes<GenericValue, "/">,
+    DString.Includes<GenericValue, "\0">
+]>> : false;

package/dist/path/types/requireLiteralSegmentPath.d.ts

@@ -0,0 +1,3 @@
+import { IsLiteralSegmentPath } from './isLiteralSegmentPath';
+import type * as DCommon from '../../common';
+export type RequireLiteralSegmentPath<GenericValue extends string> = IsLiteralSegmentPath<GenericValue> extends true ? unknown : DCommon.ComputedTypeError<"Value is not a segment path.">;

package/dist/tuple/from.cjs

@@ -0,0 +1,6 @@
+//#region scripts/tuple/from.ts
+function from(source) {
+	return source;
+}
+//#endregion
+exports.from = from;

package/dist/tuple/from.d.ts

@@ -0,0 +1,8 @@
+import { Create } from './types';
+import type * as DArray from '../array';
+type FromOutput<GenericArray extends readonly unknown[]> = DArray.ExtractLengthEqual<GenericArray, unknown> extends DArray.LengthEqual<infer InferredLength extends number> ? DArray.ReapplyCompatiblesConstraints<GenericArray, Create<GenericArray[number], InferredLength>, "maxElements"> : DArray.ExtractMinElements<GenericArray, unknown> extends DArray.MinElements<infer InferredMin extends number> ? DArray.ReapplyCompatiblesConstraints<GenericArray, readonly [
+    ...Create<GenericArray[number], InferredMin>,
+    ...GenericArray[number][]
+], "maxElements"> : GenericArray;
+export declare function from<GenericArray extends readonly unknown[]>(source: GenericArray): FromOutput<GenericArray>;
+export {};

package/dist/tuple/from.mjs

@@ -0,0 +1,6 @@
+//#region scripts/tuple/from.ts
+function from(source) {
+	return source;
+}
+//#endregion
+export { from };

package/dist/tuple/index.cjs

@@ -1,8 +1,13 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_map = require("./map.cjs");
+const require_from = require("./from.cjs");
 //#region scripts/tuple/index.ts
-var tuple_exports = /* @__PURE__ */ require_runtime.__exportAll({ map: () => require_map.map });
+var tuple_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	from: () => require_from.from,
+	map: () => require_map.map
+});
 //#endregion
+exports.from = require_from.from;
 exports.map = require_map.map;
 Object.defineProperty(exports, "tuple_exports", {
 	enumerable: true,

package/dist/tuple/index.d.ts

@@ -1,2 +1,3 @@
 export type * from './types';
 export * from './map';
+export * from './from';

package/dist/tuple/index.mjs

@@ -1,6 +1,10 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { map } from "./map.mjs";
+import { from } from "./from.mjs";
 //#region scripts/tuple/index.ts
-var tuple_exports = /* @__PURE__ */ __exportAll({ map: () => map });
+var tuple_exports = /* @__PURE__ */ __exportAll({
+	from: () => from,
+	map: () => map
+});
 //#endregion
-export { map, tuple_exports };
+export { from, map, tuple_exports };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/lang",
-  "version": "0.0.1-beta.5",
+  "version": "0.0.1-beta.6",
   "license": "MIT",
   "type": "module",
   "author": {