@duplojs/lang 0.0.0

package/dist/printer/colorized.cjs

@@ -0,0 +1,12 @@
+const require_codes = require("./codes.cjs");
+//#region scripts/printer/colorized.ts
+function colorized(...args) {
+	if (args.length === 1) {
+		const [color] = args;
+		return (input) => colorized(input, color);
+	}
+	const [input, color] = args;
+	return `${require_codes.codeColors[color]}${input}${require_codes.codeReset}`;
+}
+//#endregion
+exports.colorized = colorized;

package/dist/printer/colorized.d.ts

@@ -0,0 +1,3 @@
+import { Colors } from './types';
+export declare function colorized<GenericInput extends string>(color: Colors): (input: GenericInput) => string;
+export declare function colorized<GenericInput extends string>(input: GenericInput, color: Colors): string;

package/dist/printer/colorized.mjs

@@ -0,0 +1,12 @@
+import { codeColors, codeReset } from "./codes.mjs";
+//#region scripts/printer/colorized.ts
+function colorized(...args) {
+	if (args.length === 1) {
+		const [color] = args;
+		return (input) => colorized(input, color);
+	}
+	const [input, color] = args;
+	return `${codeColors[color]}${input}${codeReset}`;
+}
+//#endregion
+export { colorized };

package/dist/printer/colorizedBold.cjs

@@ -0,0 +1,13 @@
+const require_bold = require("./bold.cjs");
+const require_colorized = require("./colorized.cjs");
+//#region scripts/printer/colorizedBold.ts
+function colorizedBold(...args) {
+	if (args.length === 1) {
+		const [color] = args;
+		return (input) => colorizedBold(input, color);
+	}
+	const [input, color] = args;
+	return require_bold.bold(require_colorized.colorized(input, color));
+}
+//#endregion
+exports.colorizedBold = colorizedBold;

package/dist/printer/colorizedBold.d.ts

@@ -0,0 +1,3 @@
+import { Colors } from './types';
+export declare function colorizedBold<GenericInput extends string>(color: Colors): (input: GenericInput) => string;
+export declare function colorizedBold<GenericInput extends string>(input: GenericInput, color: Colors): string;

package/dist/printer/colorizedBold.mjs

@@ -0,0 +1,13 @@
+import { bold } from "./bold.mjs";
+import { colorized } from "./colorized.mjs";
+//#region scripts/printer/colorizedBold.ts
+function colorizedBold(...args) {
+	if (args.length === 1) {
+		const [color] = args;
+		return (input) => colorizedBold(input, color);
+	}
+	const [input, color] = args;
+	return bold(colorized(input, color));
+}
+//#endregion
+export { colorizedBold };

package/dist/printer/dash.d.ts

@@ -0,0 +1 @@
+export declare const dash = "-";

package/dist/printer/indent.cjs

@@ -0,0 +1,7 @@
+//#region scripts/printer/indent.ts
+function indent(level) {
+	if (level < 0 || !Number.isFinite(level)) return "";
+	return "	".repeat(level);
+}
+//#endregion
+exports.indent = indent;

package/dist/printer/indent.d.ts

@@ -0,0 +1 @@
+export declare function indent(level: number): string;

package/dist/printer/indent.mjs

@@ -0,0 +1,7 @@
+//#region scripts/printer/indent.ts
+function indent(level) {
+	if (level < 0 || !Number.isFinite(level)) return "";
+	return "	".repeat(level);
+}
+//#endregion
+export { indent };

package/dist/printer/index.cjs

@@ -0,0 +1,35 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_bold = require("./bold.cjs");
+const require_colorized = require("./colorized.cjs");
+const require_colorizedBold = require("./colorizedBold.cjs");
+const require_indent = require("./indent.cjs");
+const require_render = require("./render.cjs");
+const require_renderLine = require("./renderLine.cjs");
+const require_renderParagraph = require("./renderParagraph.cjs");
+//#region scripts/printer/index.ts
+var printer_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	back: () => "\n",
+	bold: () => require_bold.bold,
+	colorized: () => require_colorized.colorized,
+	colorizedBold: () => require_colorizedBold.colorizedBold,
+	dash: () => "-",
+	indent: () => require_indent.indent,
+	render: () => require_render.render,
+	renderLine: () => require_renderLine.renderLine,
+	renderParagraph: () => require_renderParagraph.renderParagraph,
+	tab: () => "	"
+});
+//#endregion
+exports.bold = require_bold.bold;
+exports.colorized = require_colorized.colorized;
+exports.colorizedBold = require_colorizedBold.colorizedBold;
+exports.indent = require_indent.indent;
+Object.defineProperty(exports, "printer_exports", {
+	enumerable: true,
+	get: function() {
+		return printer_exports;
+	}
+});
+exports.render = require_render.render;
+exports.renderLine = require_renderLine.renderLine;
+exports.renderParagraph = require_renderParagraph.renderParagraph;

package/dist/printer/index.d.ts

@@ -0,0 +1,11 @@
+export * from './back';
+export * from './bold';
+export * from './colorized';
+export * from './colorizedBold';
+export * from './dash';
+export * from './indent';
+export * from './render';
+export * from './renderLine';
+export * from './renderParagraph';
+export * from './tab';
+export type * from './types';

package/dist/printer/index.mjs

@@ -0,0 +1,23 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { bold } from "./bold.mjs";
+import { colorized } from "./colorized.mjs";
+import { colorizedBold } from "./colorizedBold.mjs";
+import { indent } from "./indent.mjs";
+import { render } from "./render.mjs";
+import { renderLine } from "./renderLine.mjs";
+import { renderParagraph } from "./renderParagraph.mjs";
+//#region scripts/printer/index.ts
+var printer_exports = /* @__PURE__ */ __exportAll({
+	back: () => "\n",
+	bold: () => bold,
+	colorized: () => colorized,
+	colorizedBold: () => colorizedBold,
+	dash: () => "-",
+	indent: () => indent,
+	render: () => render,
+	renderLine: () => renderLine,
+	renderParagraph: () => renderParagraph,
+	tab: () => "	"
+});
+//#endregion
+export { bold, colorized, colorizedBold, indent, printer_exports, render, renderLine, renderParagraph };

package/dist/printer/render.cjs

@@ -0,0 +1,20 @@
+//#region scripts/printer/render.ts
+function render(...args) {
+	if (args.length === 1) {
+		const [joinCharacter] = args;
+		return (values) => render(values, joinCharacter);
+	}
+	const [values, joinCharacter] = args;
+	const printableValues = [];
+	const collectPrintableValues = (value) => {
+		if (value instanceof Array) {
+			for (const childValue of value) collectPrintableValues(childValue);
+			return;
+		}
+		if (typeof value === "string" || value === true) printableValues.push(value);
+	};
+	for (const value of values) collectPrintableValues(value);
+	return printableValues.join(joinCharacter);
+}
+//#endregion
+exports.render = render;

package/dist/printer/render.d.ts

@@ -0,0 +1,3 @@
+import { RenderInput } from './types';
+export declare function render<GenericValues extends readonly RenderInput[]>(joinCharacter: string): (values: GenericValues) => string;
+export declare function render<GenericValues extends readonly RenderInput[]>(values: GenericValues, joinCharacter: string): string;

package/dist/printer/render.mjs

@@ -0,0 +1,20 @@
+//#region scripts/printer/render.ts
+function render(...args) {
+	if (args.length === 1) {
+		const [joinCharacter] = args;
+		return (values) => render(values, joinCharacter);
+	}
+	const [values, joinCharacter] = args;
+	const printableValues = [];
+	const collectPrintableValues = (value) => {
+		if (value instanceof Array) {
+			for (const childValue of value) collectPrintableValues(childValue);
+			return;
+		}
+		if (typeof value === "string" || value === true) printableValues.push(value);
+	};
+	for (const value of values) collectPrintableValues(value);
+	return printableValues.join(joinCharacter);
+}
+//#endregion
+export { render };

package/dist/printer/renderLine.cjs

@@ -0,0 +1,4 @@
+//#region scripts/printer/renderLine.ts
+const renderLine = require("./render.cjs").render(" ");
+//#endregion
+exports.renderLine = renderLine;

package/dist/printer/renderLine.d.ts

@@ -0,0 +1 @@
+export declare const renderLine: (values: readonly import('./types').RenderInput[]) => string;

package/dist/printer/renderLine.mjs

@@ -0,0 +1,5 @@
+import { render } from "./render.mjs";
+//#region scripts/printer/renderLine.ts
+const renderLine = render(" ");
+//#endregion
+export { renderLine };

package/dist/printer/renderParagraph.cjs

@@ -0,0 +1,4 @@
+//#region scripts/printer/renderParagraph.ts
+const renderParagraph = require("./render.cjs").render("\n");
+//#endregion
+exports.renderParagraph = renderParagraph;

package/dist/printer/renderParagraph.d.ts

@@ -0,0 +1 @@
+export declare const renderParagraph: (values: readonly import('./types').RenderInput[]) => string;

package/dist/printer/renderParagraph.mjs

@@ -0,0 +1,5 @@
+import { render } from "./render.mjs";
+//#region scripts/printer/renderParagraph.ts
+const renderParagraph = render("\n");
+//#endregion
+export { renderParagraph };

package/dist/printer/tab.d.ts

@@ -0,0 +1 @@
+export declare const tab = "\t";

package/dist/printer/types/colors.d.ts

@@ -0,0 +1,2 @@
+import { codeColors } from '../codes';
+export type Colors = keyof typeof codeColors;

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

@@ -0,0 +1,2 @@
+export type * from './colors';
+export type * from './renderInput';

package/dist/printer/types/renderInput.d.ts

@@ -0,0 +1 @@
+export type RenderInput = string | boolean | null | undefined | readonly RenderInput[];

package/dist/string/at.cjs

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

package/dist/string/at.d.ts

@@ -0,0 +1,3 @@
+import { At } from './types';
+export declare function at<GenericString extends string, GenericIndex extends number>(index: GenericIndex): (string: GenericString) => At<GenericString, GenericIndex>;
+export declare function at<GenericString extends string, GenericIndex extends number>(string: GenericString, index: GenericIndex): At<GenericString, GenericIndex>;

package/dist/string/at.mjs

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

package/dist/string/capitalize.cjs

@@ -0,0 +1,6 @@
+//#region scripts/string/capitalize.ts
+function capitalize(string) {
+	return `${string.charAt(0).toUpperCase()}${string.slice(1)}`;
+}
+//#endregion
+exports.capitalize = capitalize;

package/dist/string/capitalize.d.ts

@@ -0,0 +1,5 @@
+import { ReapplyCompatiblesConstraints } from './constraints';
+import type * as DCommon from '../common';
+type CapitalizeOutput<GenericString extends string> = GenericString extends unknown ? ReapplyCompatiblesConstraints<GenericString, Capitalize<Extract<DCommon.RemoveConstraint<GenericString>, string>>, "minCharacters" | "lengthEqual"> : never;
+export declare function capitalize<GenericString extends string, GenericOutput = CapitalizeOutput<GenericString>>(string: GenericString): DCommon.BreakGenericLink<GenericOutput>;
+export {};

package/dist/string/capitalize.mjs

@@ -0,0 +1,6 @@
+//#region scripts/string/capitalize.ts
+function capitalize(string) {
+	return `${string.charAt(0).toUpperCase()}${string.slice(1)}`;
+}
+//#endregion
+export { capitalize };

package/dist/string/charAt.cjs

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

package/dist/string/charAt.d.ts

@@ -0,0 +1,6 @@
+import { CharactersRange, AllowedCharacters, MaxCharacters } from './constraints';
+import type * as DNumber from '../number';
+type CharAtOutput<GenericString extends string> = GenericString extends AllowedCharacters<infer InferredCharactersRange extends CharactersRange> ? string & MaxCharacters<1> & AllowedCharacters<InferredCharactersRange> : string & MaxCharacters<1>;
+export declare function charAt<GenericString extends string, GenericIndex extends number>(index: GenericIndex & DNumber.RequirePositiveInteger<GenericIndex>): (string: GenericString) => CharAtOutput<GenericString>;
+export declare function charAt<GenericString extends string, GenericIndex extends number>(string: GenericString, index: GenericIndex & DNumber.RequirePositiveInteger<GenericIndex>): CharAtOutput<GenericString>;
+export {};

package/dist/string/charAt.mjs

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

package/dist/string/concat.cjs

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

package/dist/string/concat.d.ts

@@ -0,0 +1,14 @@
+import { ReapplyCompatiblesConstraints } from './constraints';
+import { Join } from './types';
+import type * as DCommon from '../common';
+type RemoveStringConstraints<GenericStrings extends readonly string[]> = GenericStrings extends readonly [] ? [] : GenericStrings extends readonly [
+    infer InferredHead extends string,
+    ...infer InferredRest extends readonly string[]
+] ? [
+    DCommon.RemoveConstraint<InferredHead>,
+    ...RemoveStringConstraints<InferredRest>
+] : string[];
+type ConcatOutput<GenericString extends string, GenericElement extends string, GenericElementsRest extends readonly string[] = []> = ReapplyCompatiblesConstraints<GenericString, `${Extract<DCommon.RemoveConstraint<GenericString>, string>}${Extract<DCommon.RemoveConstraint<GenericElement>, string>}${Join<RemoveStringConstraints<GenericElementsRest>>}`, "minCharacters">;
+export declare function concat<GenericString extends string, GenericElement extends string, GenericOutput = ConcatOutput<GenericString, GenericElement>>(element: GenericElement): (string: GenericString) => DCommon.BreakGenericLink<GenericOutput>;
+export declare function concat<GenericString extends string, GenericElement extends string, GenericElementsRest extends readonly string[], GenericOutput = ConcatOutput<GenericString, GenericElement, GenericElementsRest>>(string: GenericString, element: GenericElement, ...elementsRest: GenericElementsRest): DCommon.BreakGenericLink<GenericOutput>;
+export {};

package/dist/string/concat.mjs

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

package/dist/string/constraints/allowedCharacters.d.ts

@@ -0,0 +1,9 @@
+import type * as DCommon from '../../common';
+import type * as DObject from '../../object';
+export interface CharactersRangeStore {
+}
+export type CharactersRange = Extract<DObject.GetPropsWithValue<CharactersRangeStore, true>, string>;
+export type AllowedCharactersConstraintName = "string-allowed-characters";
+export interface AllowedCharacters<GenericCharactersRange extends CharactersRange = never> extends DCommon.Constraint<AllowedCharactersConstraintName, Record<GenericCharactersRange, unknown>> {
+}
+export type ExtractAllowedCharacters<GenericConstraint extends unknown, GenericDefault extends unknown = never> = GenericConstraint extends AllowedCharacters ? (keyof GenericConstraint[DCommon.ConstraintSymbol][AllowedCharactersConstraintName]) extends infer InferredResult extends CharactersRange ? DCommon.UnionToIntersection<InferredResult extends any ? AllowedCharacters<InferredResult> : never> : GenericDefault : GenericDefault;

package/dist/string/constraints/email.d.ts

@@ -0,0 +1,3 @@
+import { Format } from './format';
+export interface Email extends Format<"email", `${string}@${string}.${string}`> {
+}

package/dist/string/constraints/format.d.ts

@@ -0,0 +1,3 @@
+import type * as DCommon from '../../common';
+export interface Format<GenericName extends string, GenericFormat extends string = string> extends DCommon.Constraint<"string-format", Record<GenericName, GenericFormat>> {
+}

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

@@ -0,0 +1,11 @@
+export type * from './types';
+export type * from './allowedCharacters';
+export type * from './email';
+export type * from './format';
+export type * from './lengthEqual';
+export type * from './maxCharacters';
+export type * from './minCharacters';
+export type * from './notEmpty';
+export type * from './trimmed';
+export type * from './url';
+export type * from './uuid';

package/dist/string/constraints/lengthEqual.d.ts

@@ -0,0 +1,11 @@
+import { IsLiteral, Length } from '../types';
+import { ExtractMaxCharacters, MaxCharacters } from './maxCharacters';
+import { ExtractMinCharacters, MinCharacters } from './minCharacters';
+import type * as DNumber from '../../number';
+import type * as DCommon from '../../common';
+export type LengthEqualConstraintName = "string-length-equal";
+export interface LengthEqual<GenericLength extends number> extends DCommon.DynamicConstraint<LengthEqualConstraintName, GenericLength> {
+}
+export type ExtractLengthEqual<GenericConstraint extends unknown, GenericDefault extends unknown = never> = GenericConstraint extends unknown ? DCommon.Coalescing<DCommon.UnionToIntersection<(GenericConstraint extends LengthEqual<infer InferredLength> ? InferredLength extends number ? LengthEqual<InferredLength> : never : never) | (GenericConstraint extends string ? IsLiteral<GenericConstraint> extends true ? LengthEqual<Length<Extract<DCommon.RemoveConstraint<GenericConstraint>, string>>> : never : never)>, unknown, GenericDefault> : never;
+export type ComputeLengthEqualCompatibility<GenericValue extends unknown, GenericExpect extends unknown, GenericDefault extends unknown = never> = DCommon.NeverCoalescing<(ExtractLengthEqual<GenericExpect, unknown> extends LengthEqual<infer InferredTo> ? InferredTo extends number ? ExtractLengthEqual<GenericValue, unknown> extends LengthEqual<infer InferredFrom> ? InferredFrom extends number ? DCommon.IsEqual<InferredFrom, InferredTo> extends true ? DCommon.CompatibilityConstraintResult<true, InferredFrom, InferredTo> : DCommon.CompatibilityConstraintResult<false, InferredFrom, InferredTo> : never : never : never : never), GenericDefault>;
+export type IsImpossibleToApplyLengthEqual<GenericValue extends unknown, GenericExpect extends unknown> = DCommon.NeverCoalescing<(GenericValue extends string ? ExtractLengthEqual<GenericExpect, unknown> extends LengthEqual<infer InferredTo> ? InferredTo extends number ? ((ExtractLengthEqual<GenericValue, unknown> extends LengthEqual<infer InferredLength> ? InferredLength extends number ? DCommon.IsEqual<InferredLength, InferredTo> extends true ? false : true : never : never) | (ExtractMinCharacters<GenericValue, unknown> extends MinCharacters<infer InferredMin> ? InferredMin extends number ? DNumber.IsGreaterOrEqual<InferredTo, InferredMin> extends true ? false : true : never : never) | (ExtractMaxCharacters<GenericValue, unknown> extends MaxCharacters<infer InferredMax> ? InferredMax extends number ? DNumber.IsGreaterOrEqual<InferredMax, InferredTo> extends true ? false : true : never : never)) : never : true : false), false> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, true> extends true ? true : false : never;

package/dist/string/constraints/maxCharacters.d.ts

@@ -0,0 +1,11 @@
+import { IsLiteral, Length } from '../types';
+import { ExtractLengthEqual, LengthEqual } from './lengthEqual';
+import { ExtractMinCharacters, MinCharacters } from './minCharacters';
+import type * as DNumber from '../../number';
+import type * as DCommon from '../../common';
+export type MaxCharactersConstraintName = "string-max-characters";
+export interface MaxCharacters<GenericMax extends number> extends DCommon.DynamicConstraint<MaxCharactersConstraintName, GenericMax> {
+}
+export type ExtractMaxCharacters<GenericConstraint extends unknown, GenericDefault extends unknown = never> = GenericConstraint extends unknown ? DCommon.Coalescing<DCommon.UnionToIntersection<(GenericConstraint extends MaxCharacters<infer InferredMax> ? InferredMax extends number ? MaxCharacters<InferredMax> : never : never) | (GenericConstraint extends string ? IsLiteral<GenericConstraint> extends true ? MaxCharacters<Length<Extract<DCommon.RemoveConstraint<GenericConstraint>, string>>> : never : never) | (GenericConstraint extends LengthEqual<infer InferredLength> ? InferredLength extends number ? MaxCharacters<InferredLength> : never : never)>, unknown, GenericDefault> : never;
+export type ComputeMaxCharactersCompatibility<GenericValue extends unknown, GenericExpect extends unknown, GenericDefault extends unknown = never> = DCommon.NeverCoalescing<(ExtractMaxCharacters<GenericExpect, unknown> extends MaxCharacters<infer InferredTo> ? InferredTo extends number ? ExtractMaxCharacters<GenericValue, unknown> extends MaxCharacters<infer InferredFrom> ? InferredFrom extends number ? DNumber.IsGreaterOrEqual<InferredTo, InferredFrom> extends true ? DCommon.CompatibilityConstraintResult<true, InferredFrom, InferredTo> : DCommon.CompatibilityConstraintResult<false, InferredFrom, InferredTo> : never : never : never : never), GenericDefault>;
+export type IsImpossibleToApplyMaxCharacters<GenericValue extends unknown, GenericExpect extends unknown> = DCommon.NeverCoalescing<(GenericValue extends string ? ExtractMaxCharacters<GenericExpect, unknown> extends MaxCharacters<infer InferredTo> ? InferredTo extends number ? ((ExtractLengthEqual<GenericValue, unknown> extends LengthEqual<infer InferredLength> ? InferredLength extends number ? DNumber.IsGreaterOrEqual<InferredTo, InferredLength> extends true ? false : true : never : never) | (ExtractMinCharacters<GenericValue, unknown> extends MinCharacters<infer InferredMin> ? InferredMin extends number ? DNumber.IsGreaterOrEqual<InferredTo, InferredMin> extends true ? false : true : never : never)) : never : true : false), false> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, true> extends true ? true : false : never;

package/dist/string/constraints/minCharacters.d.ts

@@ -0,0 +1,15 @@
+import { CountMinCharacters, IsLiteral } from '../types';
+import { IsTemplateLiteral } from '../types/isTemplateLiteral';
+import { ExtractLengthEqual, LengthEqual } from './lengthEqual';
+import { ExtractMaxCharacters, MaxCharacters } from './maxCharacters';
+import type * as DNumber from '../../number';
+import type * as DCommon from '../../common';
+export type MinCharactersConstraintName = "string-min-characters";
+export interface MinCharacters<GenericMin extends number> extends DCommon.DynamicConstraint<MinCharactersConstraintName, GenericMin> {
+}
+export type ExtractMinCharacters<GenericConstraint extends unknown, GenericDefault extends unknown = never> = GenericConstraint extends unknown ? DCommon.Coalescing<DCommon.UnionToIntersection<(GenericConstraint extends MinCharacters<infer InferredMin> ? InferredMin extends number ? MinCharacters<InferredMin> : never : never) | (GenericConstraint extends string ? DCommon.Or<[
+    IsLiteral<GenericConstraint>,
+    IsTemplateLiteral<GenericConstraint>
+]> extends true ? MinCharacters<CountMinCharacters<Extract<DCommon.RemoveConstraint<GenericConstraint>, string>>> : never : never) | (GenericConstraint extends LengthEqual<infer InferredLength> ? InferredLength extends number ? MinCharacters<InferredLength> : never : never)>, unknown, GenericDefault> : never;
+export type ComputeMinCharactersCompatibility<GenericValue extends unknown, GenericExpect extends unknown, GenericDefault extends unknown = never> = DCommon.NeverCoalescing<(ExtractMinCharacters<GenericExpect, unknown> extends MinCharacters<infer InferredTo> ? InferredTo extends number ? ExtractMinCharacters<GenericValue, unknown> extends MinCharacters<infer InferredFrom> ? InferredFrom extends number ? DNumber.IsLessOrEqual<InferredTo, InferredFrom> extends true ? DCommon.CompatibilityConstraintResult<true, InferredFrom, InferredTo> : DCommon.CompatibilityConstraintResult<false, InferredFrom, InferredTo> : never : never : never : never), GenericDefault>;
+export type IsImpossibleToApplyMinCharacters<GenericValue extends unknown, GenericExpect extends unknown> = DCommon.NeverCoalescing<(GenericValue extends string ? ExtractMinCharacters<GenericExpect, unknown> extends MinCharacters<infer InferredTo> ? InferredTo extends number ? ((ExtractLengthEqual<GenericValue, unknown> extends LengthEqual<infer InferredLength> ? InferredLength extends number ? DNumber.IsGreaterOrEqual<InferredLength, InferredTo> extends true ? false : true : never : never) | (ExtractMaxCharacters<GenericValue, unknown> extends MaxCharacters<infer InferredMax> ? InferredMax extends number ? DNumber.IsGreaterOrEqual<InferredMax, InferredTo> extends true ? false : true : never : never)) : never : true : false), false> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, true> extends true ? true : false : never;

package/dist/string/constraints/notEmpty.d.ts

@@ -0,0 +1,3 @@
+import { MinCharacters } from './minCharacters';
+export interface NotEmpty extends MinCharacters<1> {
+}

package/dist/string/constraints/trimmed.d.ts

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

package/dist/string/constraints/types/applyFormat.d.ts

@@ -0,0 +1,3 @@
+import { Format } from '../format';
+import type * as DCommon from '../../../common';
+export type ApplyFormat<GenericValue extends string> = GenericValue extends Format<string, infer InferredValue> ? (GenericValue & DCommon.UnionToIntersection<InferredValue>) : GenericValue;

package/dist/string/constraints/types/index.d.ts

@@ -0,0 +1,5 @@
+export type * from './applyFormat';
+export type * from './isIndexCovered';
+export type * from './isIndexOutOfRange';
+export type * from './reapplyAllowedCharacters';
+export type * from './reapplyCompatiblesConstraints';

package/dist/string/constraints/types/isIndexCovered.d.ts

@@ -0,0 +1,5 @@
+import { ExtractLengthEqual, LengthEqual } from '../lengthEqual';
+import { ExtractMinCharacters, MinCharacters } from '../minCharacters';
+import type * as DCommon from '../../../common';
+import type * as DNumber from '../../../number';
+export type IsIndexCovered<GenericString extends string, GenericIndex extends number> = DCommon.IsEqual<GenericIndex, number> extends true ? false : ExtractMinCharacters<GenericString, unknown> extends MinCharacters<infer InferredMin> ? DNumber.IsNegative<GenericIndex> extends true ? DNumber.IsGreaterOrEqual<InferredMin, DNumber.Absolute<GenericIndex>> : DNumber.IsGreater<InferredMin, GenericIndex> : ExtractLengthEqual<GenericString, unknown> extends LengthEqual<infer InferredLength> ? DNumber.IsNegative<GenericIndex> extends true ? DNumber.IsGreaterOrEqual<InferredLength, DNumber.Absolute<GenericIndex>> : DNumber.IsGreater<InferredLength, GenericIndex> : false;

package/dist/string/constraints/types/isIndexOutOfRange.d.ts

@@ -0,0 +1,5 @@
+import { ExtractLengthEqual, LengthEqual } from '../lengthEqual';
+import { ExtractMaxCharacters, MaxCharacters } from '../maxCharacters';
+import type * as DCommon from '../../../common';
+import type * as DNumber from '../../../number';
+export type IsIndexOutOfRange<GenericString extends string, GenericIndex extends number> = ExtractMaxCharacters<GenericString, unknown> extends MaxCharacters<infer InferredMax> ? DCommon.IsEqual<GenericIndex, number> extends true ? DCommon.IsEqual<InferredMax, 0> : DNumber.IsNegative<GenericIndex> extends true ? DNumber.IsGreater<DNumber.Absolute<GenericIndex>, InferredMax> : DNumber.IsGreaterOrEqual<GenericIndex, InferredMax> : ExtractLengthEqual<GenericString, unknown> extends LengthEqual<infer InferredLength> ? DCommon.IsEqual<GenericIndex, number> extends true ? DCommon.IsEqual<InferredLength, 0> : DNumber.IsNegative<GenericIndex> extends true ? DNumber.IsGreater<DNumber.Absolute<GenericIndex>, InferredLength> : DNumber.IsGreaterOrEqual<GenericIndex, InferredLength> : false;

package/dist/string/constraints/types/reapplyAllowedCharacters.d.ts

@@ -0,0 +1,2 @@
+import { AllowedCharacters, ExtractAllowedCharacters } from '../allowedCharacters';
+export type ReapplyAllowedCharacters<GenericSource extends string, GenericOutput extends string> = ExtractAllowedCharacters<GenericSource, unknown> extends infer InferredAllowedCharacters extends AllowedCharacters<any> ? GenericOutput & InferredAllowedCharacters : GenericOutput;

package/dist/string/constraints/types/reapplyCompatiblesConstraints.d.ts

@@ -0,0 +1,25 @@
+import { ExtractLengthEqual, LengthEqual } from '../lengthEqual';
+import { ExtractMaxCharacters, MaxCharacters } from '../maxCharacters';
+import { ExtractMinCharacters, MinCharacters } from '../minCharacters';
+import { IsLiteral } from '../../types';
+import type * as DCommon from '../../../common';
+type ApplyLengthEqual<GenericOutput extends string, GenericSource extends string, GenericReapplyConstraint extends "maxCharacters" | "minCharacters" | "lengthEqual"> = "lengthEqual" extends GenericReapplyConstraint ? DCommon.Or<[
+    DCommon.ContainExtends<GenericSource, LengthEqual<number>>,
+    DCommon.Not<IsLiteral<GenericOutput>>
+]> extends true ? ExtractLengthEqual<GenericSource, unknown> extends LengthEqual<infer InferredLength> ? (GenericOutput & DCommon.UnionToIntersection<InferredLength extends number ? LengthEqual<InferredLength> : never>) : GenericOutput : GenericOutput : GenericOutput;
+type ApplyMinCharacters<GenericOutput extends string, GenericSource extends string, GenericReapplyConstraint extends "maxCharacters" | "minCharacters" | "lengthEqual"> = "minCharacters" extends GenericReapplyConstraint ? DCommon.Or<[
+    DCommon.ContainExtends<GenericSource, MinCharacters<number>>,
+    DCommon.And<[
+        DCommon.Not<DCommon.ContainExtends<GenericOutput, LengthEqual<number>>>,
+        DCommon.Not<IsLiteral<GenericOutput>>
+    ]>
+]> extends true ? ExtractMinCharacters<GenericSource, unknown> extends MinCharacters<infer InferredMin> ? (GenericOutput & DCommon.UnionToIntersection<InferredMin extends number ? MinCharacters<InferredMin> : never>) : GenericOutput : GenericOutput : GenericOutput;
+type ApplyMaxCharacters<GenericOutput extends string, GenericSource extends string, GenericReapplyConstraint extends "maxCharacters" | "minCharacters" | "lengthEqual"> = "maxCharacters" extends GenericReapplyConstraint ? DCommon.Or<[
+    DCommon.ContainExtends<GenericSource, MaxCharacters<number>>,
+    DCommon.And<[
+        DCommon.Not<DCommon.ContainExtends<GenericOutput, LengthEqual<number>>>,
+        DCommon.Not<IsLiteral<GenericOutput>>
+    ]>
+]> extends true ? ExtractMaxCharacters<GenericSource, unknown> extends MaxCharacters<infer InferredMax> ? (GenericOutput & DCommon.UnionToIntersection<InferredMax extends number ? MaxCharacters<InferredMax> : never>) : GenericOutput : GenericOutput : GenericOutput;
+export type ReapplyCompatiblesConstraints<GenericSource extends string, GenericOutput extends string, GenericReapplyConstraint extends "maxCharacters" | "minCharacters" | "lengthEqual" = "maxCharacters" | "minCharacters" | "lengthEqual"> = ApplyMaxCharacters<ApplyMinCharacters<ApplyLengthEqual<GenericOutput, GenericSource, GenericReapplyConstraint>, GenericSource, GenericReapplyConstraint>, GenericSource, GenericReapplyConstraint>;
+export {};

package/dist/string/constraints/url.d.ts

@@ -0,0 +1,3 @@
+import { Format } from './format';
+export interface Url extends Format<"url", never> {
+}

package/dist/string/constraints/uuid.d.ts

@@ -0,0 +1,3 @@
+import { Format } from './format';
+export interface Uuid extends Format<"uuid", `${string}-${string}-${string}-${string}-${string}`> {
+}

package/dist/string/endsWith.cjs

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

package/dist/string/endsWith.d.ts

@@ -0,0 +1,5 @@
+import type * as DCommon from '../common';
+type EndWithOutput<GenericString extends string, GenericSearchString extends string> = Extract<GenericString, `${string}${GenericSearchString}`> extends infer InferredResult extends GenericString ? DCommon.IsEqual<InferredResult, never> extends true ? GenericString & `${string}${GenericSearchString}` : InferredResult : never;
+export declare function endsWith<GenericString extends string, GenericSearchString extends string>(searchString: GenericSearchString): (string: GenericString) => string is EndWithOutput<GenericString, GenericSearchString>;
+export declare function endsWith<GenericString extends string, GenericSearchString extends string>(string: GenericString, searchString: GenericSearchString): string is EndWithOutput<GenericString, GenericSearchString>;
+export {};

package/dist/string/endsWith.mjs

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

package/dist/string/extract.cjs

@@ -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
+exports.extract = extract;