@duplojs/lang 0.0.0

package/dist/string/extract.d.ts

@@ -0,0 +1,9 @@
+export interface ExtractOutput<GenericString extends string = string> {
+    matchedValue: string;
+    groups: string[];
+    namedGroups: Record<string, string | undefined>;
+    offset: number;
+    self: GenericString;
+}
+export declare function extract<GenericString extends string>(pattern: string | RegExp): (string: GenericString) => ExtractOutput<GenericString> | undefined;
+export declare function extract<GenericString extends string>(string: GenericString, pattern: string | RegExp): ExtractOutput<GenericString> | undefined;

package/dist/string/extract.mjs

@@ -0,0 +1,19 @@
+//#region scripts/string/extract.ts
+function extract(...args) {
+	if (args.length === 1) {
+		const [pattern] = args;
+		return (string) => extract(string, pattern);
+	}
+	const [string, pattern] = args;
+	const result = string.match(pattern);
+	if (!result) return;
+	return {
+		matchedValue: result[0],
+		groups: result.slice(1),
+		namedGroups: result.groups ? { ...result.groups } : {},
+		offset: result.index ?? 0,
+		self: result.input ?? string
+	};
+}
+//#endregion
+export { extract };

package/dist/string/extractAll.cjs

@@ -0,0 +1,18 @@
+const require_map = require("../generator/map.cjs");
+//#region scripts/string/extractAll.ts
+function extractAll(...args) {
+	if (args.length === 1) {
+		const [pattern] = args;
+		return (string) => extractAll(string, pattern);
+	}
+	const [string, pattern] = args;
+	return require_map.map(string.matchAll(pattern), (value) => ({
+		matchedValue: value[0],
+		groups: value.slice(1),
+		namedGroups: value.groups ? { ...value.groups } : void 0,
+		offset: value.index ?? 0,
+		self: value.input ?? string
+	}));
+}
+//#endregion
+exports.extractAll = extractAll;

package/dist/string/extractAll.d.ts

@@ -0,0 +1,3 @@
+import { ExtractOutput } from './extract';
+export declare function extractAll<GenericString extends string>(pattern: RegExp): (string: GenericString) => Generator<ExtractOutput<GenericString>>;
+export declare function extractAll<GenericString extends string>(string: GenericString, pattern: RegExp): Generator<ExtractOutput<GenericString>>;

package/dist/string/extractAll.mjs

@@ -0,0 +1,18 @@
+import { map } from "../generator/map.mjs";
+//#region scripts/string/extractAll.ts
+function extractAll(...args) {
+	if (args.length === 1) {
+		const [pattern] = args;
+		return (string) => extractAll(string, pattern);
+	}
+	const [string, pattern] = args;
+	return map(string.matchAll(pattern), (value) => ({
+		matchedValue: value[0],
+		groups: value.slice(1),
+		namedGroups: value.groups ? { ...value.groups } : void 0,
+		offset: value.index ?? 0,
+		self: value.input ?? string
+	}));
+}
+//#endregion
+export { extractAll };

package/dist/string/first.cjs

@@ -0,0 +1,6 @@
+//#region scripts/string/first.ts
+function first(string) {
+	return string.at(0);
+}
+//#endregion
+exports.first = first;

package/dist/string/first.d.ts

@@ -0,0 +1,2 @@
+import { First } from './types';
+export declare function first<GenericString extends string>(string: GenericString): First<GenericString>;

package/dist/string/first.mjs

@@ -0,0 +1,6 @@
+//#region scripts/string/first.ts
+function first(string) {
+	return string.at(0);
+}
+//#endregion
+export { first };

package/dist/string/includes.cjs

@@ -0,0 +1,11 @@
+//#region scripts/string/includes.ts
+function includes(...args) {
+	if (args.length === 1) {
+		const [searchString] = args;
+		return (string) => includes(string, searchString);
+	}
+	const [string, searchString] = args;
+	return string.includes(searchString);
+}
+//#endregion
+exports.includes = includes;

package/dist/string/includes.d.ts

@@ -0,0 +1,5 @@
+import { ApplyFormat } from './constraints';
+type IncludesOutput<GenericString extends string, GenericSearchString extends string> = GenericString extends string ? ApplyFormat<GenericString> extends `${string}${GenericSearchString}${string}` ? GenericString : GenericString & `${string}${GenericSearchString}${string}` : never;
+export declare function includes<GenericString extends string, GenericSearchString extends string>(searchString: GenericSearchString): (string: GenericString) => string is IncludesOutput<GenericString, GenericSearchString>;
+export declare function includes<GenericString extends string, GenericSearchString extends string>(string: GenericString, searchString: GenericSearchString): string is IncludesOutput<GenericString, GenericSearchString>;
+export {};

package/dist/string/includes.mjs

@@ -0,0 +1,11 @@
+//#region scripts/string/includes.ts
+function includes(...args) {
+	if (args.length === 1) {
+		const [searchString] = args;
+		return (string) => includes(string, searchString);
+	}
+	const [string, searchString] = args;
+	return string.includes(searchString);
+}
+//#endregion
+export { includes };

package/dist/string/index.cjs

@@ -0,0 +1,165 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_at = require("./at.cjs");
+const require_capitalize = require("./capitalize.cjs");
+const require_charAt = require("./charAt.cjs");
+const require_concat = require("./concat.cjs");
+const require_endsWith = require("./endsWith.cjs");
+const require_extract = require("./extract.cjs");
+const require_extractAll = require("./extractAll.cjs");
+const require_first = require("./first.cjs");
+const require_includes = require("./includes.cjs");
+const require_indexOf = require("./indexOf.cjs");
+const require_infer = require("./infer.cjs");
+const require_isComposedOf = require("./isComposedOf.cjs");
+const require_isEmail = require("./isEmail.cjs");
+const require_isIn = require("./isIn.cjs");
+const require_isKeyof = require("./isKeyof.cjs");
+const require_isNotEmpty = require("./isNotEmpty.cjs");
+const require_isUrl = require("./isUrl.cjs");
+const require_isUuid = require("./isUuid.cjs");
+const require_join = require("./join.cjs");
+const require_last = require("./last.cjs");
+const require_lastIndexOf = require("./lastIndexOf.cjs");
+const require_length = require("./length.cjs");
+const require_lengthEqual = require("./lengthEqual.cjs");
+const require_maxCharacters = require("./maxCharacters.cjs");
+const require_minCharacters = require("./minCharacters.cjs");
+const require_normalize = require("./normalize.cjs");
+const require_padEnd = require("./padEnd.cjs");
+const require_padStart = require("./padStart.cjs");
+const require_pop = require("./pop.cjs");
+const require_prepend = require("./prepend.cjs");
+const require_repeat = require("./repeat.cjs");
+const require_replace = require("./replace.cjs");
+const require_replaceAll = require("./replaceAll.cjs");
+const require_search = require("./search.cjs");
+const require_shift = require("./shift.cjs");
+const require_slice = require("./slice.cjs");
+const require_sort = require("./sort.cjs");
+const require_sortCompare = require("./sortCompare.cjs");
+const require_split = require("./split.cjs");
+const require_startsWith = require("./startsWith.cjs");
+const require_stringify = require("./stringify.cjs");
+const require_substring = require("./substring.cjs");
+const require_test = require("./test.cjs");
+const require_to = require("./to.cjs");
+const require_toLowerCase = require("./toLowerCase.cjs");
+const require_toUpperCase = require("./toUpperCase.cjs");
+const require_default = require("./trim/default.cjs");
+const require_end = require("./trim/end.cjs");
+const require_start = require("./trim/start.cjs");
+const require_uncapitalize = require("./uncapitalize.cjs");
+//#region scripts/string/index.ts
+var string_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	at: () => require_at.at,
+	capitalize: () => require_capitalize.capitalize,
+	charAt: () => require_charAt.charAt,
+	concat: () => require_concat.concat,
+	emailRegex: () => require_isEmail.emailRegex,
+	endsWith: () => require_endsWith.endsWith,
+	extract: () => require_extract.extract,
+	extractAll: () => require_extractAll.extractAll,
+	first: () => require_first.first,
+	includes: () => require_includes.includes,
+	indexOf: () => require_indexOf.indexOf,
+	infer: () => require_infer.infer,
+	isComposedOf: () => require_isComposedOf.isComposedOf,
+	isEmail: () => require_isEmail.isEmail,
+	isIn: () => require_isIn.isIn,
+	isKeyof: () => require_isKeyof.isKeyof,
+	isNotEmpty: () => require_isNotEmpty.isNotEmpty,
+	isUrl: () => require_isUrl.isUrl,
+	isUuid: () => require_isUuid.isUuid,
+	join: () => require_join.join,
+	last: () => require_last.last,
+	lastIndexOf: () => require_lastIndexOf.lastIndexOf,
+	length: () => require_length.length,
+	lengthEqual: () => require_lengthEqual.lengthEqual,
+	maxCharacters: () => require_maxCharacters.maxCharacters,
+	minCharacters: () => require_minCharacters.minCharacters,
+	normalize: () => require_normalize.normalize,
+	padEnd: () => require_padEnd.padEnd,
+	padStart: () => require_padStart.padStart,
+	pop: () => require_pop.pop,
+	prepend: () => require_prepend.prepend,
+	repeat: () => require_repeat.repeat,
+	replace: () => require_replace.replace,
+	replaceAll: () => require_replaceAll.replaceAll,
+	search: () => require_search.search,
+	shift: () => require_shift.shift,
+	slice: () => require_slice.slice,
+	sort: () => require_sort.sort,
+	sortCompare: () => require_sortCompare.sortCompare,
+	split: () => require_split.split,
+	startsWith: () => require_startsWith.startsWith,
+	stringify: () => require_stringify.stringify,
+	substring: () => require_substring.substring,
+	test: () => require_test.test,
+	to: () => require_to.to,
+	toLowerCase: () => require_toLowerCase.toLowerCase,
+	toUpperCase: () => require_toUpperCase.toUpperCase,
+	trim: () => require_default.trim,
+	trimEnd: () => require_end.trimEnd,
+	trimStart: () => require_start.trimStart,
+	uncapitalize: () => require_uncapitalize.uncapitalize,
+	uuidRegex: () => require_isUuid.uuidRegex
+});
+//#endregion
+exports.at = require_at.at;
+exports.capitalize = require_capitalize.capitalize;
+exports.charAt = require_charAt.charAt;
+exports.concat = require_concat.concat;
+exports.emailRegex = require_isEmail.emailRegex;
+exports.endsWith = require_endsWith.endsWith;
+exports.extract = require_extract.extract;
+exports.extractAll = require_extractAll.extractAll;
+exports.first = require_first.first;
+exports.includes = require_includes.includes;
+exports.indexOf = require_indexOf.indexOf;
+exports.infer = require_infer.infer;
+exports.isComposedOf = require_isComposedOf.isComposedOf;
+exports.isEmail = require_isEmail.isEmail;
+exports.isIn = require_isIn.isIn;
+exports.isKeyof = require_isKeyof.isKeyof;
+exports.isNotEmpty = require_isNotEmpty.isNotEmpty;
+exports.isUrl = require_isUrl.isUrl;
+exports.isUuid = require_isUuid.isUuid;
+exports.join = require_join.join;
+exports.last = require_last.last;
+exports.lastIndexOf = require_lastIndexOf.lastIndexOf;
+exports.length = require_length.length;
+exports.lengthEqual = require_lengthEqual.lengthEqual;
+exports.maxCharacters = require_maxCharacters.maxCharacters;
+exports.minCharacters = require_minCharacters.minCharacters;
+exports.normalize = require_normalize.normalize;
+exports.padEnd = require_padEnd.padEnd;
+exports.padStart = require_padStart.padStart;
+exports.pop = require_pop.pop;
+exports.prepend = require_prepend.prepend;
+exports.repeat = require_repeat.repeat;
+exports.replace = require_replace.replace;
+exports.replaceAll = require_replaceAll.replaceAll;
+exports.search = require_search.search;
+exports.shift = require_shift.shift;
+exports.slice = require_slice.slice;
+exports.sort = require_sort.sort;
+exports.sortCompare = require_sortCompare.sortCompare;
+exports.split = require_split.split;
+exports.startsWith = require_startsWith.startsWith;
+Object.defineProperty(exports, "string_exports", {
+	enumerable: true,
+	get: function() {
+		return string_exports;
+	}
+});
+exports.stringify = require_stringify.stringify;
+exports.substring = require_substring.substring;
+exports.test = require_test.test;
+exports.to = require_to.to;
+exports.toLowerCase = require_toLowerCase.toLowerCase;
+exports.toUpperCase = require_toUpperCase.toUpperCase;
+exports.trim = require_default.trim;
+exports.trimEnd = require_end.trimEnd;
+exports.trimStart = require_start.trimStart;
+exports.uncapitalize = require_uncapitalize.uncapitalize;
+exports.uuidRegex = require_isUuid.uuidRegex;

package/dist/string/index.d.ts

@@ -0,0 +1,50 @@
+export * from './at';
+export * from './capitalize';
+export * from './charAt';
+export * from './concat';
+export type * from './constraints';
+export * from './endsWith';
+export * from './extract';
+export * from './extractAll';
+export * from './first';
+export * from './includes';
+export * from './indexOf';
+export * from './infer';
+export * from './isComposedOf';
+export * from './isEmail';
+export * from './isIn';
+export * from './isKeyof';
+export * from './isNotEmpty';
+export * from './isUrl';
+export * from './isUuid';
+export * from './join';
+export * from './last';
+export * from './lastIndexOf';
+export * from './length';
+export * from './lengthEqual';
+export * from './maxCharacters';
+export * from './minCharacters';
+export * from './normalize';
+export * from './padEnd';
+export * from './padStart';
+export * from './pop';
+export * from './prepend';
+export * from './repeat';
+export * from './replace';
+export * from './replaceAll';
+export * from './search';
+export * from './shift';
+export * from './slice';
+export * from './sort';
+export * from './sortCompare';
+export * from './split';
+export * from './startsWith';
+export * from './stringify';
+export * from './substring';
+export * from './test';
+export * from './to';
+export * from './toLowerCase';
+export * from './toUpperCase';
+export * from './trim';
+export type * from './types';
+export * from './uncapitalize';

package/dist/string/index.mjs

@@ -0,0 +1,108 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { at } from "./at.mjs";
+import { capitalize } from "./capitalize.mjs";
+import { charAt } from "./charAt.mjs";
+import { concat } from "./concat.mjs";
+import { endsWith } from "./endsWith.mjs";
+import { extract } from "./extract.mjs";
+import { extractAll } from "./extractAll.mjs";
+import { first } from "./first.mjs";
+import { includes } from "./includes.mjs";
+import { indexOf } from "./indexOf.mjs";
+import { infer } from "./infer.mjs";
+import { isComposedOf } from "./isComposedOf.mjs";
+import { emailRegex, isEmail } from "./isEmail.mjs";
+import { isIn } from "./isIn.mjs";
+import { isKeyof } from "./isKeyof.mjs";
+import { isNotEmpty } from "./isNotEmpty.mjs";
+import { isUrl } from "./isUrl.mjs";
+import { isUuid, uuidRegex } from "./isUuid.mjs";
+import { join } from "./join.mjs";
+import { last } from "./last.mjs";
+import { lastIndexOf } from "./lastIndexOf.mjs";
+import { length } from "./length.mjs";
+import { lengthEqual } from "./lengthEqual.mjs";
+import { maxCharacters } from "./maxCharacters.mjs";
+import { minCharacters } from "./minCharacters.mjs";
+import { normalize } from "./normalize.mjs";
+import { padEnd } from "./padEnd.mjs";
+import { padStart } from "./padStart.mjs";
+import { pop } from "./pop.mjs";
+import { prepend } from "./prepend.mjs";
+import { repeat } from "./repeat.mjs";
+import { replace } from "./replace.mjs";
+import { replaceAll } from "./replaceAll.mjs";
+import { search } from "./search.mjs";
+import { shift } from "./shift.mjs";
+import { slice } from "./slice.mjs";
+import { sort } from "./sort.mjs";
+import { sortCompare } from "./sortCompare.mjs";
+import { split } from "./split.mjs";
+import { startsWith } from "./startsWith.mjs";
+import { stringify } from "./stringify.mjs";
+import { substring } from "./substring.mjs";
+import { test } from "./test.mjs";
+import { to } from "./to.mjs";
+import { toLowerCase } from "./toLowerCase.mjs";
+import { toUpperCase } from "./toUpperCase.mjs";
+import { trim } from "./trim/default.mjs";
+import { trimEnd } from "./trim/end.mjs";
+import { trimStart } from "./trim/start.mjs";
+import { uncapitalize } from "./uncapitalize.mjs";
+//#region scripts/string/index.ts
+var string_exports = /* @__PURE__ */ __exportAll({
+	at: () => at,
+	capitalize: () => capitalize,
+	charAt: () => charAt,
+	concat: () => concat,
+	emailRegex: () => emailRegex,
+	endsWith: () => endsWith,
+	extract: () => extract,
+	extractAll: () => extractAll,
+	first: () => first,
+	includes: () => includes,
+	indexOf: () => indexOf,
+	infer: () => infer,
+	isComposedOf: () => isComposedOf,
+	isEmail: () => isEmail,
+	isIn: () => isIn,
+	isKeyof: () => isKeyof,
+	isNotEmpty: () => isNotEmpty,
+	isUrl: () => isUrl,
+	isUuid: () => isUuid,
+	join: () => join,
+	last: () => last,
+	lastIndexOf: () => lastIndexOf,
+	length: () => length,
+	lengthEqual: () => lengthEqual,
+	maxCharacters: () => maxCharacters,
+	minCharacters: () => minCharacters,
+	normalize: () => normalize,
+	padEnd: () => padEnd,
+	padStart: () => padStart,
+	pop: () => pop,
+	prepend: () => prepend,
+	repeat: () => repeat,
+	replace: () => replace,
+	replaceAll: () => replaceAll,
+	search: () => search,
+	shift: () => shift,
+	slice: () => slice,
+	sort: () => sort,
+	sortCompare: () => sortCompare,
+	split: () => split,
+	startsWith: () => startsWith,
+	stringify: () => stringify,
+	substring: () => substring,
+	test: () => test,
+	to: () => to,
+	toLowerCase: () => toLowerCase,
+	toUpperCase: () => toUpperCase,
+	trim: () => trim,
+	trimEnd: () => trimEnd,
+	trimStart: () => trimStart,
+	uncapitalize: () => uncapitalize,
+	uuidRegex: () => uuidRegex
+});
+//#endregion
+export { at, capitalize, charAt, concat, emailRegex, endsWith, extract, extractAll, first, includes, indexOf, infer, isComposedOf, isEmail, isIn, isKeyof, isNotEmpty, isUrl, isUuid, join, last, lastIndexOf, length, lengthEqual, maxCharacters, minCharacters, normalize, padEnd, padStart, pop, prepend, repeat, replace, replaceAll, search, shift, slice, sort, sortCompare, split, startsWith, string_exports, stringify, substring, test, to, toLowerCase, toUpperCase, trim, trimEnd, trimStart, uncapitalize, uuidRegex };

package/dist/string/indexOf.cjs

@@ -0,0 +1,12 @@
+//#region scripts/string/indexOf.ts
+function indexOf(...args) {
+	if (args.length === 1) {
+		const [searchString] = args;
+		return (string) => indexOf(string, searchString);
+	}
+	const [string, searchString, position] = args;
+	const result = string.indexOf(searchString, position);
+	return result === -1 ? void 0 : result;
+}
+//#endregion
+exports.indexOf = indexOf;

package/dist/string/indexOf.d.ts

@@ -0,0 +1,2 @@
+export declare function indexOf<GenericString extends string>(searchString: string): (string: GenericString) => number | undefined;
+export declare function indexOf<GenericString extends string>(string: GenericString, searchString: string, position?: number): number | undefined;

package/dist/string/indexOf.mjs

@@ -0,0 +1,12 @@
+//#region scripts/string/indexOf.ts
+function indexOf(...args) {
+	if (args.length === 1) {
+		const [searchString] = args;
+		return (string) => indexOf(string, searchString);
+	}
+	const [string, searchString, position] = args;
+	const result = string.indexOf(searchString, position);
+	return result === -1 ? void 0 : result;
+}
+//#endregion
+export { indexOf };

package/dist/string/infer.cjs

@@ -0,0 +1,6 @@
+//#region scripts/string/infer.ts
+function infer(input) {
+	return input;
+}
+//#endregion
+exports.infer = infer;

package/dist/string/infer.d.ts

@@ -0,0 +1,12 @@
+import { MaxCharacters, MinCharacters, LengthEqual, ComputeMaxCharactersCompatibility, ComputeMinCharactersCompatibility, ComputeLengthEqualCompatibility } from './constraints';
+import { RequireLiteral } from './types';
+import type * as DCommon from '../common';
+type ComputeCompatibilityOutputConstraint<GenericOutput extends string, GenericInput extends string> = (DCommon.Or<[
+    DCommon.IsNever<GenericOutput>,
+    DCommon.IsNever<GenericInput>
+]> extends true ? unknown : GenericOutput extends unknown ? ((ComputeMaxCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? MaxCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MaxCharacters<${InferredResult["to"]}> because constraint MaxCharacters<${InferredResult["from"]}> from the value is more than.`> : never) | (ComputeMinCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? MinCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MinCharacters<${InferredResult["to"]}> because constraint MinCharacters<${InferredResult["from"]}> from the value is less than.`> : never) | (ComputeLengthEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? LengthEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`> : never)) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.ComputedTypeError<string>> extends true ? Extract<InferredResult, DCommon.ComputedTypeError<string>> : DCommon.UnionToIntersection<InferredResult> : never : never) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.BaseConstraint> extends true ? Extract<InferredResult, DCommon.BaseConstraint> : InferredResult : never;
+export declare function infer<GenericOutput extends string, const GenericInput extends Extract<DCommon.RemoveConstraint<GenericOutput>, string> = never, GenericConstraint = ComputeCompatibilityOutputConstraint<GenericOutput, GenericInput>>(input: (GenericInput & RequireLiteral<GenericInput> & DCommon.ForbiddenUnion<GenericInput> & DCommon.BreakGenericLink<DCommon.ContainExtends<GenericConstraint, DCommon.ComputedTypeError<string>> extends true ? GenericConstraint : unknown>)): DCommon.Or<[
+    DCommon.IsNever<GenericInput>,
+    DCommon.ContainExtends<GenericConstraint, DCommon.ComputedTypeError<string>>
+]> extends true ? GenericOutput : DCommon.BreakGenericLink<GenericInput & GenericConstraint>;
+export {};

package/dist/string/infer.mjs

@@ -0,0 +1,6 @@
+//#region scripts/string/infer.ts
+function infer(input) {
+	return input;
+}
+//#endregion
+export { infer };

package/dist/string/isComposedOf.cjs

@@ -0,0 +1,19 @@
+const require_coalescing = require("../array/coalescing.cjs");
+//#region scripts/string/isComposedOf.ts
+const charactersRangeStore = /* @__PURE__ */ new Map([
+	["a-z", "a-z"],
+	["A-Z", "A-Z"],
+	["A-z", "A-z"],
+	["0-9", "0-9"]
+]);
+function isComposedOf(...args) {
+	if (args.length === 1) {
+		const [charactersRange] = args;
+		return (value) => isComposedOf(value, charactersRange);
+	}
+	const [value, charactersRange] = args;
+	const charactersRangePattern = require_coalescing.coalescing(charactersRange).map((range) => charactersRangeStore.get(range)).join("");
+	return new RegExp(`^[${charactersRangePattern}]*$`).test(value);
+}
+//#endregion
+exports.isComposedOf = isComposedOf;

package/dist/string/isComposedOf.d.ts

@@ -0,0 +1,14 @@
+import { AllowedCharacters, CharactersRange } from './constraints';
+import type * as DCommon from '../common';
+declare module "./constraints" {
+    interface CharactersRangeStore {
+        "a-z": true;
+        "A-Z": true;
+        "A-z": true;
+        "0-9": true;
+    }
+}
+type ContainsIsComposedOf<GenericValue extends string, GenericCharactersRange extends CharactersRange> = DCommon.UnionToIntersection<(GenericCharactersRange extends any ? AllowedCharacters<GenericCharactersRange> : never)> extends infer InferredConstraints extends DCommon.Constraint ? GenericValue extends InferredConstraints ? GenericValue : GenericValue & InferredConstraints : never;
+export declare function isComposedOf<GenericValue extends string, GenericCharactersRange extends CharactersRange>(charactersRange: DCommon.MaybeArray<GenericCharactersRange>): (value: GenericValue) => value is ContainsIsComposedOf<GenericValue, GenericCharactersRange>;
+export declare function isComposedOf<GenericValue extends string, GenericCharactersRange extends CharactersRange>(value: GenericValue, charactersRange: DCommon.MaybeArray<GenericCharactersRange>): value is ContainsIsComposedOf<GenericValue, GenericCharactersRange>;
+export {};

package/dist/string/isComposedOf.mjs

@@ -0,0 +1,19 @@
+import { coalescing } from "../array/coalescing.mjs";
+//#region scripts/string/isComposedOf.ts
+const charactersRangeStore = /* @__PURE__ */ new Map([
+	["a-z", "a-z"],
+	["A-Z", "A-Z"],
+	["A-z", "A-z"],
+	["0-9", "0-9"]
+]);
+function isComposedOf(...args) {
+	if (args.length === 1) {
+		const [charactersRange] = args;
+		return (value) => isComposedOf(value, charactersRange);
+	}
+	const [value, charactersRange] = args;
+	const charactersRangePattern = coalescing(charactersRange).map((range) => charactersRangeStore.get(range)).join("");
+	return new RegExp(`^[${charactersRangePattern}]*$`).test(value);
+}
+//#endregion
+export { isComposedOf };

package/dist/string/isEmail.cjs

@@ -0,0 +1,8 @@
+//#region scripts/string/isEmail.ts
+const emailRegex = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/;
+function isEmail(string) {
+	return emailRegex.test(string);
+}
+//#endregion
+exports.emailRegex = emailRegex;
+exports.isEmail = isEmail;

package/dist/string/isEmail.d.ts

@@ -0,0 +1,3 @@
+import { Email } from './constraints';
+export declare const emailRegex: RegExp;
+export declare function isEmail<GenericString extends string>(string: GenericString): string is GenericString & Email;

package/dist/string/isEmail.mjs

@@ -0,0 +1,7 @@
+//#region scripts/string/isEmail.ts
+const emailRegex = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/;
+function isEmail(string) {
+	return emailRegex.test(string);
+}
+//#endregion
+export { emailRegex, isEmail };

package/dist/string/isIn.cjs

@@ -0,0 +1,11 @@
+//#region scripts/string/isIn.ts
+function isIn(...args) {
+	if (args.length === 1) {
+		const [array] = args;
+		return (string) => isIn(string, array);
+	}
+	const [string, array] = args;
+	return array.includes(string);
+}
+//#endregion
+exports.isIn = isIn;

package/dist/string/isIn.d.ts

@@ -0,0 +1,2 @@
+export declare function isIn<GenericValue extends string>(array: readonly (GenericValue | string)[]): (string: string) => string is GenericValue;
+export declare function isIn<GenericValue extends string>(string: string, array: readonly (GenericValue | string)[]): string is GenericValue;

package/dist/string/isIn.mjs

@@ -0,0 +1,11 @@
+//#region scripts/string/isIn.ts
+function isIn(...args) {
+	if (args.length === 1) {
+		const [array] = args;
+		return (string) => isIn(string, array);
+	}
+	const [string, array] = args;
+	return array.includes(string);
+}
+//#endregion
+export { isIn };

package/dist/string/isKeyof.cjs

@@ -0,0 +1,11 @@
+//#region scripts/string/isKeyof.ts
+function isKeyof(...args) {
+	if (args.length === 1) {
+		const [object] = args;
+		return (key) => isKeyof(key, object);
+	}
+	const [key, object] = args;
+	return object[key] !== void 0;
+}
+//#endregion
+exports.isKeyof = isKeyof;

package/dist/string/isKeyof.d.ts

@@ -0,0 +1,3 @@
+import type * as DCommon from '../common';
+export declare function isKeyof<GenericObject extends object, GenericKey extends DCommon.ObjectKey>(object: GenericObject): (key: GenericKey) => key is keyof GenericObject & GenericKey;
+export declare function isKeyof<GenericObject extends object, GenericKey extends DCommon.ObjectKey>(key: GenericKey, object: GenericObject): key is keyof GenericObject & GenericKey;