@duplojs/utils 1.4.32 → 1.4.33

package/dist/string/capitalize.d.ts

@@ -1 +1,28 @@
+/**
+ * Uppercases the first character of a string.
+ * 
+ * Signature: `capitalize(input)` → returns the capitalized string
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * S.capitalize("zeriix"); // "Zeriix"
+ * 
+ * pipe(
+ * 	"alpha",
+ * 	S.capitalize,
+ * ); // "Alpha"
+ * 
+ * S.capitalize("DUPLO"); // "DUPLO"
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`String.prototype.charAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt) and [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/capitalize
+ * 
+ * @namespace S
+ * 
+ */
 export declare function capitalize<GenericString extends string>(input: GenericString): Capitalize<GenericString>;

package/dist/string/capitalize.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include string/capitalize/index.md}
+ */
 function capitalize(input) {
     return `${input.charAt(0).toUpperCase()}${input.slice(1)}`;
 }

package/dist/string/charAt.d.ts

@@ -1,2 +1,31 @@
+/**
+ * Returns the character at the given index.
+ * 
+ * **Supported call styles:**
+ * - Classic: `charAt(input, index)` → returns a character
+ * - Curried: `charAt(index)` → returns a function waiting for the input
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * S.charAt("DuploJS", 0); // "D"
+ * 
+ * pipe(
+ * 	"Utilities",
+ * 	S.charAt(0),
+ * ); // "U"
+ * 
+ * S.charAt("Alpha", 2); // "p"
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`String.prototype.charAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/charAt
+ * 
+ * @namespace S
+ * 
+ */
 export declare function charAt<GenericInput extends string>(index: number): (input: GenericInput) => string;
 export declare function charAt(input: string, index: number): string;

package/dist/string/concat.d.ts

@@ -1,2 +1,33 @@
+/**
+ * Concatenates strings into a new string.
+ * 
+ * **Supported call styles:**
+ * - Classic: `concat(input, text, ...textsRest)` → returns a new string
+ * - Curried: `concat(text)` → returns a function waiting for the input
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * S.concat("Duplo", "JS", " Utils"); // "DuploJS Utils"
+ * 
+ * pipe(
+ * 	"Duplo",
+ * 	S.concat("JS"),
+ * ); // "DuploJS"
+ * 
+ * S.concat("Hello", " ", "World"); // "Hello World"
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Classic style supports concatenating multiple strings via rest parameters
+ * - Curried style concatenates only two strings (`text` into `input`)
+ * - Uses the same semantics as [`String.prototype.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/concat
+ * 
+ * @namespace S
+ * 
+ */
 export declare function concat<GenericInput extends string>(text: string): (input: GenericInput) => string;
 export declare function concat(input: string, ...textsRest: string[]): string;

package/dist/string/endsWith.d.ts

@@ -1,5 +1,46 @@
 import { type IsEqual } from "../common";
 type ComputeResult<GenericString extends string, GenericSearchString extends string> = Extract<GenericString, `${string}${GenericSearchString}`> extends infer InferredResult extends GenericString ? IsEqual<InferredResult, never> extends true ? GenericString & `${string}${GenericSearchString}` : InferredResult : never;
+/**
+ * Checks whether a string ends with a substring.
+ * 
+ * **Supported call styles:**
+ * - Classic: `endsWith(input, searchString)` → returns a boolean
+ * - Curried: `endsWith(searchString)` → returns a function waiting for the input
+ * - Classic predicate: `endsWith(input, searchString)` → narrows the string type
+ * - Curried predicate: `endsWith(searchString)` → narrows the string type
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * const maybeValue = true ? "DuploJS" : "DuploTS";
+ * 
+ * if (S.endsWith(maybeValue, "JS")) {
+ * 	// maybeValue is "DuploJS"
+ * }
+ * 
+ * pipe(
+ * 	maybeValue,
+ * 	when(
+ * 		S.endsWith("JS"),
+ * 		(value) => {
+ * 			// value is "DuploJS"
+ * 		},
+ * 	),
+ * );
+ * 
+ * S.endsWith("DuploJS", "JS"); // true
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Predicate overloads (type guards) narrow the output type
+ * - Uses the same semantics as [`String.prototype.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/endsWith
+ * 
+ * @namespace S
+ * 
+ */
 export declare function endsWith<GenericString extends string, GenericSearchString extends string>(searchString: GenericSearchString): (input: GenericString) => input is ComputeResult<GenericString, GenericSearchString>;
 export declare function endsWith<GenericString extends string, GenericSearchString extends string>(input: GenericString, searchString: GenericSearchString): input is ComputeResult<GenericString, GenericSearchString>;
 export {};

package/dist/string/includes.d.ts

@@ -1,5 +1,46 @@
 import { type IsEqual } from "../common";
 type ComputeResult<GenericString extends string, GenericSearchString extends string> = Extract<GenericString, `${string}${GenericSearchString}${string}`> extends infer InferredResult extends GenericString ? IsEqual<InferredResult, never> extends true ? GenericString & `${string}${GenericSearchString}${string}` : InferredResult : never;
+/**
+ * Checks whether a string contains a substring.
+ * 
+ * **Supported call styles:**
+ * - Classic: `includes(input, searchString)` → returns a boolean
+ * - Curried: `includes(searchString)` → returns a function waiting for the input
+ * - Classic predicate: `includes(input, searchString)` → narrows the string type
+ * - Curried predicate: `includes(searchString)` → narrows the string type
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * const maybeValue = true ? "DuplpoJS" : "DuploTS";
+ * 
+ * if (S.includes(maybeValue, "JS")) {
+ * 	// maybeValue is "DuplpoJS"
+ * }
+ * 
+ * pipe(
+ * 	maybeValue,
+ * 	when(
+ * 		S.includes("JS"),
+ * 		(value) => {
+ * 			// value is "DuplpoJS"
+ * 		},
+ * 	),
+ * );
+ * 
+ * S.includes("DuploJS", "JS"); // true
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Predicate overloads (type guards) narrow the output type
+ * - Uses the same semantics as [`String.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/includes
+ * 
+ * @namespace S
+ * 
+ */
 export declare function includes<GenericString extends string, GenericSearchString extends string>(searchString: GenericSearchString): (input: GenericString) => input is ComputeResult<GenericString, GenericSearchString>;
 export declare function includes<GenericString extends string, GenericSearchString extends string>(input: GenericString, searchString: GenericSearchString): input is ComputeResult<GenericString, GenericSearchString>;
 export {};

package/dist/string/index.cjs

@@ -36,7 +36,9 @@ var _default$1 = require('./trim/default.cjs');
 var end = require('./trim/end.cjs');
 var start = require('./trim/start.cjs');
 
-
+/**
+ * {@include string/index.md}
+ */
 
 exports.isKeyof = isKeyof.isKeyof;
 exports.split = split.split;

package/dist/string/index.d.ts

@@ -1,3 +1,30 @@
+/**
+ * String utilities for immutable, type-safe string manipulation. Functions preserve the
+ * original string and return new values.
+ * 
+ * **How to import:**
+ * - From the main entry (namespace style)
+ * - Via direct import for tree-shaking
+ * 
+ * ```ts
+ * import { DString, S } from "@duplojs/utils";
+ * import * as DString from "@duplojs/utils/string";
+ * import * as S from "@duplojs/utils/string";
+ * ```
+ * 
+ * What you will find in this namespace:
+ * - casing and trimming (`S.toUpperCase`, `S.toLowerCase`, `S.capitalize`, `S.uncapitalize`, `S.trim`)
+ * - search and match (`S.includes`, `S.startsWith`, `S.endsWith`, `S.search`, `S.match`, `S.matchAll`, `S.test`)
+ * - composition and slicing (`S.concat`, `S.slice`, `S.substring`, `S.split`)
+ * - indexing (`S.at`, `S.charAt`, `S.indexOf`, `S.lastIndexOf`)
+ * - padding and repeat (`S.padStart`, `S.padEnd`, `S.repeat`)
+ * - misc helpers (`S.normalize`, `S.isKeyof`, `S.isIn`, `S.length`, `S.sort`, `S.sortCompare`)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string
+ * 
+ * @namespace S
+ * 
+ */
 export * from "./types";
 export * from "./isKeyof";
 export * from "./at";

package/dist/string/index.mjs

@@ -33,3 +33,7 @@ export { last } from './at/last.mjs';
 export { trim } from './trim/default.mjs';
 export { trimEnd } from './trim/end.mjs';
 export { trimStart } from './trim/start.mjs';
+
+/**
+ * {@include string/index.md}
+ */

package/dist/string/indexOf.d.ts

@@ -1,2 +1,32 @@
+/**
+ * Finds the first index of a substring.
+ * 
+ * **Supported call styles:**
+ * - Classic: `indexOf(input, searchString, position?)` → returns an index or `undefined`
+ * - Curried: `indexOf(searchString)` → returns a function waiting for the input
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * S.indexOf("DuploJS Utils", "JS"); // 5
+ * 
+ * S.indexOf("DuploJS Utils", "JS", 6); // undefined
+ * 
+ * pipe(
+ * 	"DuploJS Utils",
+ * 	S.indexOf("Utils"),
+ * ); // 8
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Returns `undefined` when the substring is not found
+ * - Uses the same semantics as [`String.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/indexOf
+ * 
+ * @namespace S
+ * 
+ */
 export declare function indexOf<GenericInput extends string>(searchString: string): (input: GenericInput) => number | undefined;
 export declare function indexOf(input: string, searchString: string, position?: number): number | undefined;

package/dist/string/isIn.d.ts

@@ -1,2 +1,47 @@
+/**
+ * Checks whether a string is present in a list.
+ * 
+ * **Supported call styles:**
+ * - Classic: `isIn(input, list)` → returns a boolean
+ * - Curried: `isIn(list)` → returns a function waiting for the input
+ * - Classic predicate: `isIn(input, list)` → narrows the string type
+ * - Curried predicate: `isIn(list)` → narrows the string type
+ * 
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * const statusList = [
+ * 	"draft",
+ * 	"published",
+ * ];
+ * 
+ * const maybeStatus = true ? "draft" : "archived";
+ * 
+ * if (S.isIn(maybeStatus, statusList)) {
+ * 	// maybeStatus is "draft" | "published"
+ * }
+ * 
+ * pipe(
+ * 	maybeStatus,
+ * 	when(
+ * 		S.isIn(statusList),
+ * 		(value) => {
+ * 			// value is "draft" | "published"
+ * 		},
+ * 	),
+ * );
+ * 
+ * S.isIn("archived", statusList); // false
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Predicate overloads (type guards) narrow the output type
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/isIn
+ * 
+ * @namespace S
+ * 
+ */
 export declare function isIn<GenericInput extends string, GenericValue extends GenericInput>(array: readonly GenericValue[]): (input: GenericInput) => input is Extract<GenericInput, GenericValue>;
 export declare function isIn<GenericInput extends string, GenericValue extends GenericInput>(input: GenericInput, array: readonly GenericValue[]): input is Extract<GenericInput, GenericValue>;

package/dist/string/isKeyof.d.ts

@@ -1,3 +1,48 @@
 import { type ObjectKey } from "../common/types/objectKey";
+/**
+ * Checks whether a key exists on an object.
+ * 
+ * **Supported call styles:**
+ * - Classic: `isKeyof(key, obj)` → returns a boolean
+ * - Curried: `isKeyof(obj)` → returns a function waiting for the key
+ * - Classic predicate: `isKeyof(key, obj)` → narrows the key type
+ * - Curried predicate: `isKeyof(obj)` → narrows the key type
+ * 
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * const userObject = {
+ * 	name: "John",
+ * 	age: 30,
+ * };
+ * 
+ * const keyValue = "name" as string;
+ * 
+ * if (S.isKeyof(keyValue, userObject)) {
+ * 	// keyValue is a key of userObject
+ * }
+ * 
+ * pipe(
+ * 	"age",
+ * 	when(
+ * 		S.isKeyof(userObject),
+ * 		(value) => {
+ * 			// value is a key of userObject
+ * 		},
+ * 	),
+ * );
+ * 
+ * S.isKeyof("title", userObject); // false
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Predicate overloads (type guards) narrow the key type
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/isKeyof
+ * 
+ * @namespace S
+ * 
+ */
 export declare function isKeyof<GenericObject extends object, GenericKey extends ObjectKey>(obj: GenericObject): (key: GenericKey) => key is keyof GenericObject & GenericKey;
 export declare function isKeyof<GenericObject extends object, GenericKey extends ObjectKey>(key: GenericKey, obj: GenericObject): key is keyof GenericObject & GenericKey;

package/dist/string/lastIndexOf.d.ts

@@ -1,2 +1,32 @@
+/**
+ * Finds the last index of a substring.
+ * 
+ * **Supported call styles:**
+ * - Classic: `lastIndexOf(input, searchString, position?)` → returns an index or `undefined`
+ * - Curried: `lastIndexOf(searchString)` → returns a function waiting for the input
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * S.lastIndexOf("DuploJS Utils", "JS"); // 5
+ * 
+ * S.lastIndexOf("DuploJS Utils", "JS", 5); // undefined
+ * 
+ * pipe(
+ * 	"DuploJS Utils",
+ * 	S.lastIndexOf("Utils"),
+ * ); // 8
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Returns `undefined` when the substring is not found
+ * - Uses the same semantics as [`String.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/lastIndexOf
+ * 
+ * @namespace S
+ * 
+ */
 export declare function lastIndexOf<GenericInput extends string>(searchString: string): (input: GenericInput) => number | undefined;
 export declare function lastIndexOf<GenericInput extends string>(input: GenericInput, searchString: string, position?: number): number | undefined;

package/dist/string/length.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include string/length/index.md}
+ */
 function length(input) {
     return input.length;
 }

package/dist/string/length.d.ts

@@ -1,2 +1,26 @@
 import { type StringLength } from "./types/stringLength";
+/**
+ * Returns the length of a string.
+ * 
+ * Signature: `length(input)` → returns the string length
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * S.length("DuploJS"); // 7
+ * 
+ * pipe(
+ * 	"TypeScript",
+ * 	S.length,
+ * ); // 10
+ * 
+ * S.length(""); // 0
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/length
+ * 
+ * @namespace S
+ * 
+ */
 export declare function length<GenericInput extends string>(input: GenericInput): StringLength<GenericInput>;

package/dist/string/length.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include string/length/index.md}
+ */
 function length(input) {
     return input.length;
 }

package/dist/string/match.d.ts

@@ -1,2 +1,31 @@
+/**
+ * Finds the first match of a pattern in a string.
+ * 
+ * **Supported call styles:**
+ * - Classic: `match(input, pattern)` → returns a match array or `undefined`
+ * - Curried: `match(pattern)` → returns a function waiting for the input
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * S.match("foo_foo_foo", /f.o_/); // ["foo_"]
+ * 
+ * S.match("foo_foo_foo", "foo"); // ["foo"]
+ * 
+ * pipe(
+ * 	"alpha_beta",
+ * 	S.match(/a../),
+ * ); // ["alph"]
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/match
+ * 
+ * @namespace S
+ * 
+ */
 export declare function match<GenericInput extends string>(pattern: string | RegExp): (input: GenericInput) => RegExpMatchArray | undefined;
 export declare function match<GenericInput extends string>(input: GenericInput, pattern: string | RegExp): RegExpMatchArray | undefined;

package/dist/string/matchAll.d.ts

@@ -1,2 +1,38 @@
+/**
+ * Finds all matches of a pattern in a string.
+ * 
+ * **Supported call styles:**
+ * - Classic: `matchAll(input, pattern)` → returns an iterator of matches
+ * - Curried: `matchAll(pattern)` → returns a function waiting for the input
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * pipe(
+ * 	"foo_foo_foo",
+ * 	S.matchAll(/f.o_/g),
+ * 	A.from,
+ * 	A.map(A.first),
+ * 	A.filter((value) => value !== undefined),
+ * ); // ["foo_", "foo_", "foo_"]
+ * 
+ * S.matchAll("alpha_beta", /a../g); // RegExpStringIterator
+ * 
+ * pipe(
+ * 	"one_two",
+ * 	S.matchAll(/\w+/g),
+ * 	A.from,
+ * ); // ["one", "two"]
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`String.prototype.matchAll`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/matchAll
+ * 
+ * @namespace S
+ * 
+ */
 export declare function matchAll<GenericInput extends string>(pattern: RegExp): (input: GenericInput) => RegExpStringIterator<RegExpMatchArray>;
 export declare function matchAll<GenericInput extends string>(input: GenericInput, pattern: RegExp): RegExpStringIterator<RegExpMatchArray>;

package/dist/string/normalize.d.ts

@@ -1,3 +1,32 @@
 import { type NormalizeForm } from "./types/normalizeForm";
+/**
+ * Normalizes a string using the specified Unicode normalization form.
+ * 
+ * **Supported call styles:**
+ * - Classic: `normalize(input, form)` → returns a normalized string
+ * - Curried: `normalize(form)` → returns a function waiting for the input
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * S.normalize("Café", "NFD"); // "Café"
+ * 
+ * pipe(
+ * 	"e\u0301",
+ * 	S.normalize("NFC"),
+ * ); // "é"
+ * 
+ * S.normalize("Duplo", "NFKD"); // "Duplo"
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`String.prototype.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/normalize
+ * 
+ * @namespace S
+ * 
+ */
 export declare function normalize<GenericInput extends string>(form: NormalizeForm): (input: GenericInput) => string;
 export declare function normalize<GenericInput extends string>(input: GenericInput, form: NormalizeForm): string;

package/dist/string/padEnd.d.ts

@@ -1,2 +1,31 @@
+/**
+ * Pads a string at the end to reach a target length.
+ * 
+ * **Supported call styles:**
+ * - Classic: `padEnd(input, targetLength, padString)` → returns a padded string
+ * - Curried: `padEnd(targetLength, padString)` → returns a function waiting for the input
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * S.padEnd("abc", 6, "."); // "abc..."
+ * 
+ * pipe(
+ * 	"42",
+ * 	S.padEnd(4, "0"),
+ * ); // "4200"
+ * 
+ * S.padEnd("duplo", 7, "!"); // "duplo!!"
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`String.prototype.padEnd`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/padEnd
+ * 
+ * @namespace S
+ * 
+ */
 export declare function padEnd<GenericInput extends string>(targetLength: number, padString: string): (input: GenericInput) => string;
 export declare function padEnd<GenericInput extends string>(input: GenericInput, targetLength: number, padString: string): string;

package/dist/string/padStart.d.ts

@@ -1,2 +1,31 @@
+/**
+ * Pads a string at the start to reach a target length.
+ * 
+ * **Supported call styles:**
+ * - Classic: `padStart(input, targetLength, padString)` → returns a padded string
+ * - Curried: `padStart(targetLength, padString)` → returns a function waiting for the input
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * S.padStart("7", 3, "0"); // "007"
+ * 
+ * pipe(
+ * 	"42",
+ * 	S.padStart(4, "0"),
+ * ); // "0042"
+ * 
+ * S.padStart("abc", 5, "."); // "..abc"
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`String.prototype.padStart`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/padStart
+ * 
+ * @namespace S
+ * 
+ */
 export declare function padStart<GenericInput extends string>(targetLength: number, padString: string): (input: GenericInput) => string;
 export declare function padStart<GenericInput extends string>(input: GenericInput, targetLength: number, padString: string): string;

package/dist/string/repeat.d.ts

@@ -1,2 +1,31 @@
+/**
+ * Repeats a string a number of times.
+ * 
+ * **Supported call styles:**
+ * - Classic: `repeat(input, count)` → returns a repeated string
+ * - Curried: `repeat(count)` → returns a function waiting for the input
+ * 
+ * The input string is not mutated.
+ * 
+ * ```ts
+ * S.repeat("abc", 3); // "abcabcabc"
+ * 
+ * pipe(
+ * 	"-",
+ * 	S.repeat(5),
+ * ); // "-----"
+ * 
+ * S.repeat("Duplo", 2); // "DuploDuplo"
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`String.prototype.repeat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/repeat
+ * 
+ * @namespace S
+ * 
+ */
 export declare function repeat<GenericInput extends string>(count: number): (input: GenericInput) => string;
 export declare function repeat<GenericInput extends string>(input: GenericInput, count: number): string;