@duplojs/utils 0.3.1 → 1.0.1

package/dist/pattern/types/complexUnMatchedValue/getIncompleteUnion.d.ts

@@ -0,0 +1,66 @@
+import { type AnyTuple, type Adaptor, type IsEqual, type Or } from "../../../common";
+import { type PatternValueMaybeAll, type EligiblePrimitiveMatch } from "../pattern";
+import { type FlatObject } from "../../../object";
+import { type ExcludeTuple } from "../../../array/types/excludeTuple";
+export type GetIncompleteUnion<GenericInput extends unknown, GenericPatternValue extends unknown> = (([
+    Extract<GenericInput, EligiblePrimitiveMatch>,
+    Extract<GenericPatternValue, EligiblePrimitiveMatch>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? IsEqual<InferredPatternValue, never> extends true ? never : IsEqual<Exclude<InferredInput, InferredPatternValue>, never> extends true ? {} : true : never) | ([
+    Exclude<Extract<GenericInput, object>, GenericPatternValue | readonly any[]>,
+    Exclude<Extract<GenericPatternValue, object>, readonly any[]>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? IsEqual<InferredPatternValue, never> extends true ? never : IsEqual<InferredInput, Exclude<Extract<GenericInput, object>, readonly any[]>> extends true ? FlatObject<{
+    [Prop in (InferredPatternValue extends any ? keyof InferredPatternValue : never)]: GetIncompleteUnion<InferredInput[Adaptor<Prop, keyof InferredInput>], Extract<InferredPatternValue, {
+        [SubProp in Prop]: any;
+    }>[Prop]>;
+}> : IsEqual<InferredInput, never> extends true ? {} : {
+    "@duplojs/utils/{object}": true;
+} : never) | ([
+    ExcludeTuple<Extract<GenericInput, AnyTuple>, Extract<GenericPatternValue, readonly any[]>>,
+    Extract<GenericPatternValue, AnyTuple | readonly []>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? IsEqual<InferredPatternValue, never> extends true ? never : IsEqual<InferredInput, Extract<GenericInput, AnyTuple>> extends true ? [
+    InferredInput,
+    InferredPatternValue
+] extends [
+    readonly [infer InferredInputFirst, ...infer InferredInputRest],
+    readonly [infer InferredPatternValueFirst, ...infer InferredPatternValueRest]
+] ? GetIncompleteUnion<InferredInputFirst, InferredPatternValueFirst> extends infer InferredResultFirst ? FlatObject<{
+    "@duplojs/utils/[tuple.first": InferredResultFirst;
+    "@duplojs/utils/tuple.rest]": GetIncompleteUnion<InferredInputRest, InferredPatternValueRest>;
+}> : never : never : IsEqual<InferredInput, never> extends true ? {} : {
+    "@duplojs/utils/[tuple]": true;
+} : never) | ([
+    Exclude<Extract<GenericInput, readonly any[]>, AnyTuple>,
+    Extract<GenericPatternValue, AnyTuple>
+] extends [
+    infer InferredInput extends readonly any[],
+    infer InferredPatternValue
+] ? Or<[
+    IsEqual<InferredPatternValue, never>,
+    IsEqual<InferredInput, never>
+]> extends true ? never : InferredPatternValue extends readonly [
+    infer InferredPatternValueFirst,
+    ...infer InferredPatternValueRest
+] ? GetIncompleteUnion<InferredInput[number], InferredPatternValueFirst> extends infer InferredResultFirst ? FlatObject<{
+    "@duplojs/utils/[array.first": InferredResultFirst;
+    "@duplojs/utils/array.rest]": IsEqual<InferredResultFirst, {}> extends true ? GetIncompleteUnion<InferredInput, InferredPatternValueRest> : never;
+}> : {} : {} : never) | (Extract<GenericPatternValue, PatternValueMaybeAll> extends infer InferredPatternValue ? IsEqual<InferredPatternValue, never> extends true ? never : {
+    "@duplojs/utils/{maybeAll}": true;
+} : never) | ([
+    Extract<GenericInput, readonly any[]>,
+    Extract<GenericPatternValue, readonly []>
+] extends [
+    infer InferredInput extends readonly any[],
+    infer InferredPatternValue
+] ? Or<[
+    IsEqual<InferredPatternValue, never>,
+    IsEqual<InferredInput, never>
+]> extends true ? never : {} : never));

package/dist/pattern/types/complexUnMatchedValue/index.d.ts

@@ -0,0 +1,9 @@
+import { type UnionToTuple } from "../../../common";
+import { type GetIncompleteUnion } from "./getIncompleteUnion";
+import { type ComplexUnMatchedPrimitive } from "./primitive";
+import { type ComplexUnMatchedObject } from "./object";
+import { type ComplexUnMatchedUnionObject } from "./unionObject";
+import { type ComplexUnMatchedArray } from "./array";
+import { type PatternValueMaybeAll } from "../pattern";
+import { type ComplexUnMatchedMaybeAll } from "./maybeAll";
+export type ComplexUnMatchedValue<GenericInput extends unknown, GenericPatternValue extends unknown> = UnionToTuple<keyof GetIncompleteUnion<GenericInput, GenericPatternValue>>["length"] extends 0 | 1 ? Exclude<GenericPatternValue, PatternValueMaybeAll> extends infer InferredPatternValue ? (ComplexUnMatchedPrimitive<GenericInput, InferredPatternValue> | ComplexUnMatchedObject<GenericInput, InferredPatternValue> | ComplexUnMatchedArray<GenericInput, InferredPatternValue> | ComplexUnMatchedUnionObject<GenericInput, InferredPatternValue> | ComplexUnMatchedMaybeAll<GenericInput, GenericPatternValue>) : never : GenericInput;

package/dist/pattern/types/complexUnMatchedValue/maybeAll.d.ts

@@ -0,0 +1,3 @@
+import { type Unwrap, type IsEqual } from "../../../common";
+import { type PatternValueMaybeAll } from "../pattern";
+export type ComplexUnMatchedMaybeAll<GenericInput extends unknown, GenericPatternValue extends unknown> = Extract<GenericPatternValue, PatternValueMaybeAll> extends infer InferredPatternValue ? IsEqual<InferredPatternValue, never> extends true ? never : Extract<Unwrap<InferredPatternValue>, GenericInput> : never;

package/dist/pattern/types/complexUnMatchedValue/object.d.ts

@@ -0,0 +1,17 @@
+import { type Adaptor, type SimplifyTopLevel, type IsEqual, type IsUnion, type NeverCoalescing, type RemoveReadonly } from "../../../common";
+import { type ComplexUnMatchedValue } from ".";
+export type ComplexUnMatchedObject<GenericInput extends unknown, GenericPatternValue extends unknown> = ([
+    Exclude<Extract<GenericInput, object>, readonly any[]>,
+    Exclude<Extract<GenericPatternValue, object>, readonly any[]>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? IsEqual<InferredPatternValue, never> extends true ? InferredInput : IsUnion<InferredPatternValue> extends true ? never : InferredInput extends any ? InferredInput extends InferredPatternValue ? never : IsEqual<Extract<keyof InferredInput, keyof InferredPatternValue>, keyof InferredPatternValue> extends false ? InferredInput : (IsEqual<{
+    [Prop in keyof InferredPatternValue]: ComplexUnMatchedValue<InferredInput[Adaptor<Prop, keyof InferredInput>], InferredPatternValue[Prop]>;
+} extends infer InferredObjectArray extends object ? InferredObjectArray[keyof InferredObjectArray] : never, never> extends true ? never : ({
+    -readonly [Prop in keyof InferredPatternValue]: NeverCoalescing<Extract<ComplexUnMatchedValue<InferredInput[Adaptor<Prop, keyof InferredInput>], InferredPatternValue[Prop]>, any>, InferredInput[Adaptor<Prop, keyof InferredInput>]>;
+} & Omit<InferredInput, keyof InferredPatternValue>) extends infer InferredObject extends object ? ({
+    [Prop in keyof InferredObject as undefined extends InferredObject[Prop] ? Prop : never]?: InferredObject[Prop];
+} & {
+    [Prop in keyof InferredObject as undefined extends InferredObject[Prop] ? never : Prop]: InferredObject[Prop];
+}) extends infer InferredResult ? IsEqual<RemoveReadonly<InferredResult>, RemoveReadonly<InferredInput>> extends true ? InferredInput : SimplifyTopLevel<InferredResult> : never : never) : never : never);

package/dist/pattern/types/complexUnMatchedValue/primitive.d.ts

@@ -0,0 +1,8 @@
+import { type EligiblePrimitiveMatch } from "../pattern";
+export type ComplexUnMatchedPrimitive<GenericInput extends unknown, GenericPatternValue extends unknown> = ([
+    Extract<GenericInput, EligiblePrimitiveMatch>,
+    Extract<GenericPatternValue, EligiblePrimitiveMatch>
+] extends [
+    infer inferredInput,
+    infer inferredPatternValue
+] ? Exclude<inferredInput, inferredPatternValue> : never);

package/dist/pattern/types/complexUnMatchedValue/unionObject.d.ts

@@ -0,0 +1,3 @@
+import { type RemoveDuplicateInUnion, type IsUnion } from "../../../common";
+import { type ComplexUnMatchedValue } from ".";
+export type ComplexUnMatchedUnionObject<GenericInput extends unknown, GenericPatternValue extends unknown> = (IsUnion<Extract<GenericPatternValue, object>> extends false ? never : Extract<GenericPatternValue, any> extends infer InferredPatternValue ? (InferredPatternValue extends object ? ComplexUnMatchedValue<GenericInput, InferredPatternValue> extends infer InferredResult ? ComplexUnMatchedValue<InferredResult, Exclude<GenericPatternValue, InferredPatternValue>> : never : never) extends infer InferredResult ? RemoveDuplicateInUnion<InferredResult> : never : never);

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

@@ -0,0 +1,3 @@
+export * from "./complexMatchedValue";
+export * from "./complexUnMatchedValue";
+export * from "./pattern";

package/dist/pattern/types/pattern.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+const SymbolToolPatternFunctionLabel = "SymbolToolPatternFunctionLabel";
+
+exports.SymbolToolPatternFunctionLabel = SymbolToolPatternFunctionLabel;

package/dist/pattern/types/pattern.d.ts

@@ -0,0 +1,37 @@
+import { type MergeUnionTuple } from "../../array/types/mergeUnionTuple";
+import { type AnyTuple, type Adaptor, type IsEqual, type ObjectKey, type WrappedValue } from "../../common";
+export type EligiblePrimitiveMatch = string | number | bigint | boolean | undefined | null;
+type PrimitivePattern<GenericInput extends unknown> = GenericInput extends EligiblePrimitiveMatch ? GenericInput : never;
+type ObjectPattern<GenericInput extends unknown> = Exclude<GenericInput, readonly any[]> extends infer InferredInput ? [
+    Extract<InferredInput, object>,
+    InferredInput extends object ? keyof InferredInput : never
+] extends [
+    infer InferredInputObject extends object,
+    infer InferredInputKeyofObject extends ObjectKey
+] ? {
+    readonly [Prop in InferredInputKeyofObject]?: Extract<InferredInputObject, Partial<Record<Prop, any>>> extends infer InferredValue extends object ? Prop extends keyof InferredValue ? Pattern<InferredValue[Prop]> : never : never;
+} extends infer InferredResult ? IsEqual<InferredResult, {}> extends true ? never : InferredResult : never : never : never;
+type ArrayPattern<GenericInput extends unknown> = ((Extract<GenericInput, AnyTuple> extends infer InferredInput extends AnyTuple ? IsEqual<InferredInput, never> extends true ? never : MergeUnionTuple<InferredInput> extends readonly [infer InferredFirst, ...infer InferredRest] ? (readonly [] | readonly [Pattern<InferredFirst>] | (InferredRest extends readonly [] ? never : readonly [
+    Pattern<InferredFirst>,
+    ...Adaptor<Pattern<InferredRest>, readonly any[]>
+])) : never : never) | (Exclude<Extract<GenericInput, readonly any[]>, AnyTuple> extends infer InferredInput extends readonly any[] ? IsEqual<InferredInput, never> extends true ? never : readonly Pattern<InferredInput[number]>[] : never));
+type PredicatePattern<GenericInput extends unknown = any> = (input: GenericInput) => boolean;
+declare const SymbolToolPattern: unique symbol;
+type SymbolToolPattern = typeof SymbolToolPattern;
+export declare const SymbolToolPatternFunctionLabel = "SymbolToolPatternFunctionLabel";
+declare const SymbolToolPatternFunction: unique symbol;
+type SymbolToolPatternFunction = typeof SymbolToolPatternFunction;
+export interface ToolPattern<GenericInput extends unknown = any, GenericPattern extends unknown = any> {
+    [SymbolToolPatternFunction](input: GenericInput): boolean;
+    [SymbolToolPattern]: GenericPattern;
+}
+export type Pattern<GenericInput extends unknown = any> = (PredicatePattern<GenericInput> | ToolPattern<GenericInput> | PrimitivePattern<GenericInput> | ObjectPattern<GenericInput> | ArrayPattern<GenericInput>);
+declare const SymbolPatternValueMaybeAll: unique symbol;
+type SymbolPatternValueMaybeAll = typeof SymbolPatternValueMaybeAll;
+export interface PatternValueMaybeAll<GenericValue extends unknown = any> extends WrappedValue<GenericValue> {
+    [SymbolPatternValueMaybeAll]: unknown;
+}
+export type PatternValue<GenericPattern extends Pattern> = GenericPattern extends EligiblePrimitiveMatch ? GenericPattern : GenericPattern extends (input: any) => input is infer InferredPredicate ? InferredPredicate : GenericPattern extends (input: infer InferredInput) => boolean ? PatternValueMaybeAll<InferredInput> : GenericPattern extends ToolPattern<any, infer InferredPattern> ? PatternValue<InferredPattern> : GenericPattern extends readonly [infer inferredFirst, ...infer inferredRest] ? IsEqual<inferredRest, readonly []> extends true ? [PatternValue<inferredFirst>] : [PatternValue<inferredFirst>, ...Adaptor<PatternValue<inferredRest>, any[]>] : GenericPattern extends readonly [] ? [] : GenericPattern extends readonly any[] ? PatternValue<GenericPattern[number]>[] : GenericPattern extends Record<ObjectKey, Pattern> ? {
+    [Prop in keyof GenericPattern]: PatternValue<GenericPattern[Prop]>;
+} : never;
+export {};

package/dist/pattern/types/pattern.mjs

@@ -0,0 +1,3 @@
+const SymbolToolPatternFunctionLabel = "SymbolToolPatternFunctionLabel";
+
+export { SymbolToolPatternFunctionLabel };

package/dist/pattern/union.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var isMatch = require('./isMatch.cjs');
+var pattern = require('./types/pattern.cjs');
+
+const SymbolToolPatternFunction = Symbol.for(pattern.SymbolToolPatternFunctionLabel);
+function union(...patterns) {
+    return {
+        [SymbolToolPatternFunction]: (input) => {
+            for (const pattern of patterns) {
+                if (isMatch.isMatch(input, pattern)) {
+                    return true;
+                }
+            }
+            return false;
+        },
+    };
+}
+
+exports.union = union;

package/dist/pattern/union.d.ts

@@ -0,0 +1,6 @@
+import { type FixDeepFunctionInfer } from "../common";
+import { type Pattern, type ToolPattern } from "./types/pattern";
+export declare function union<GenericInput extends unknown, const GenericPatterns extends readonly [
+    Pattern<GenericInput extends infer InferredInput ? InferredInput : never>,
+    ...Pattern<GenericInput extends infer InferredInput ? InferredInput : never>[]
+]>(...patterns: FixDeepFunctionInfer<readonly [Pattern<GenericInput>, ...Pattern<GenericInput>[]], GenericPatterns>): ToolPattern<GenericInput, GenericPatterns[number] extends infer InferredPattern ? InferredPattern : never>;

package/dist/pattern/union.mjs

@@ -0,0 +1,18 @@
+import { isMatch } from './isMatch.mjs';
+import { SymbolToolPatternFunctionLabel } from './types/pattern.mjs';
+
+const SymbolToolPatternFunction = Symbol.for(SymbolToolPatternFunctionLabel);
+function union(...patterns) {
+    return {
+        [SymbolToolPatternFunction]: (input) => {
+            for (const pattern of patterns) {
+                if (isMatch(input, pattern)) {
+                    return true;
+                }
+            }
+            return false;
+        },
+    };
+}
+
+export { union };

package/dist/string/at/default.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function at(...args) {
+    if (args.length === 1) {
+        const [index] = args;
+        return (input) => at(input, index);
+    }
+    const [input, index] = args;
+    return input.at(index);
+}
+
+exports.at = at;

package/dist/string/at/default.d.ts

@@ -0,0 +1,2 @@
+export declare function at<GenericString extends string, GenericIndex extends number>(index: GenericIndex): (input: GenericString) => string | undefined;
+export declare function at<GenericString extends string, GenericIndex extends number>(input: GenericString, index: GenericIndex): string | undefined;

package/dist/string/at/default.mjs

@@ -0,0 +1,10 @@
+function at(...args) {
+    if (args.length === 1) {
+        const [index] = args;
+        return (input) => at(input, index);
+    }
+    const [input, index] = args;
+    return input.at(index);
+}
+
+export { at };

package/dist/string/at/first.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function first(input) {
+    return input[0];
+}
+
+exports.first = first;

package/dist/string/at/first.d.ts

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

package/dist/string/at/first.mjs

@@ -0,0 +1,5 @@
+function first(input) {
+    return input[0];
+}
+
+export { first };

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

@@ -0,0 +1,3 @@
+export * from "./default";
+export * from "./first";
+export * from "./last";

package/dist/string/at/last.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+function last(string) {
+    return string.length > 0
+        ? string[string.length - 1]
+        : undefined;
+}
+
+exports.last = last;

package/dist/string/at/last.d.ts

@@ -0,0 +1,2 @@
+import { type Last } from "../types";
+export declare function last<GenericValue extends string>(string: GenericValue): Last<GenericValue>;

package/dist/string/at/last.mjs

@@ -0,0 +1,7 @@
+function last(string) {
+    return string.length > 0
+        ? string[string.length - 1]
+        : undefined;
+}
+
+export { last };

package/dist/string/capitalize.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function capitalize(input) {
+    return (input.charAt(0).toUpperCase() + input.slice(1));
+}
+
+exports.capitalize = capitalize;

package/dist/string/capitalize.d.ts

@@ -0,0 +1 @@
+export declare function capitalize<GenericString extends string>(input: GenericString): Capitalize<GenericString>;

package/dist/string/capitalize.mjs

@@ -0,0 +1,5 @@
+function capitalize(input) {
+    return (input.charAt(0).toUpperCase() + input.slice(1));
+}
+
+export { capitalize };

package/dist/string/charAt.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function charAt(...args) {
+    if (args.length === 1) {
+        const [index] = args;
+        return (input) => charAt(input, index);
+    }
+    const [input, index] = args;
+    return input.charAt(index);
+}
+
+exports.charAt = charAt;

package/dist/string/charAt.d.ts

@@ -0,0 +1,2 @@
+export declare function charAt<GenericInput extends string>(index: number): (input: GenericInput) => string;
+export declare function charAt(input: string, index: number): string;

package/dist/string/charAt.mjs

@@ -0,0 +1,10 @@
+function charAt(...args) {
+    if (args.length === 1) {
+        const [index] = args;
+        return (input) => charAt(input, index);
+    }
+    const [input, index] = args;
+    return input.charAt(index);
+}
+
+export { charAt };

package/dist/string/concat.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function concat(...args) {
+    if (args.length === 1) {
+        const [text] = args;
+        return (input) => concat(input, text);
+    }
+    const [input, ...textsRest] = args;
+    return input.concat(...textsRest);
+}
+
+exports.concat = concat;

package/dist/string/concat.d.ts

@@ -0,0 +1,2 @@
+export declare function concat<GenericInput extends string>(text: string): (input: GenericInput) => string;
+export declare function concat(input: string, ...textsRest: string[]): string;

package/dist/string/concat.mjs

@@ -0,0 +1,10 @@
+function concat(...args) {
+    if (args.length === 1) {
+        const [text] = args;
+        return (input) => concat(input, text);
+    }
+    const [input, ...textsRest] = args;
+    return input.concat(...textsRest);
+}
+
+export { concat };

package/dist/string/endsWith.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function endsWith(...args) {
+    if (args.length === 1) {
+        const [searchString] = args;
+        return (input) => endsWith(input, searchString);
+    }
+    const [input, searchString] = args;
+    return input.endsWith(searchString);
+}
+
+exports.endsWith = endsWith;

package/dist/string/endsWith.d.ts

@@ -0,0 +1,2 @@
+export declare function endsWith<GenericSearchString extends string, GenericString extends string>(searchString: GenericSearchString): (input: GenericString) => input is Extract<GenericString, `${string}${GenericSearchString}`>;
+export declare function endsWith<GenericString extends string, GenericSearchString extends string>(input: GenericString, searchString: GenericSearchString): input is Extract<GenericString, `${string}${GenericSearchString}`>;

package/dist/string/endsWith.mjs

@@ -0,0 +1,10 @@
+function endsWith(...args) {
+    if (args.length === 1) {
+        const [searchString] = args;
+        return (input) => endsWith(input, searchString);
+    }
+    const [input, searchString] = args;
+    return input.endsWith(searchString);
+}
+
+export { endsWith };

package/dist/string/includes.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function includes(...args) {
+    if (args.length === 1) {
+        const [searchString] = args;
+        return (input) => includes(input, searchString);
+    }
+    const [input, searchString] = args;
+    return input.includes(searchString);
+}
+
+exports.includes = includes;

package/dist/string/includes.d.ts

@@ -0,0 +1,2 @@
+export declare function includes<GenericSearchString extends string, GenericString extends string>(searchString: GenericSearchString): (input: GenericString) => input is Extract<GenericString, `${string}${GenericSearchString}${string}`>;
+export declare function includes<GenericString extends string, GenericSearchString extends string>(input: GenericString, searchString: GenericSearchString): input is Extract<GenericString, `${string}${GenericSearchString}${string}`>;

package/dist/string/includes.mjs

@@ -0,0 +1,10 @@
+function includes(...args) {
+    if (args.length === 1) {
+        const [searchString] = args;
+        return (input) => includes(input, searchString);
+    }
+    const [input, searchString] = args;
+    return input.includes(searchString);
+}
+
+export { includes };

package/dist/string/index.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+var isKeyof = require('./isKeyof.cjs');
+var _default = require('./at/default.cjs');
+var first = require('./at/first.cjs');
+var last = require('./at/last.cjs');
+var split = require('./split.cjs');
+var charAt = require('./charAt.cjs');
+var toUpperCase = require('./toUpperCase.cjs');
+var toLowerCase = require('./toLowerCase.cjs');
+var _default$1 = require('./trim/default.cjs');
+var end = require('./trim/end.cjs');
+var start = require('./trim/start.cjs');
+var capitalize = require('./capitalize.cjs');
+var uncapitalize = require('./uncapitalize.cjs');
+var substring = require('./substring.cjs');
+var startsWith = require('./startsWith.cjs');
+var endsWith = require('./endsWith.cjs');
+var includes = require('./includes.cjs');
+var search = require('./search.cjs');
+var replace = require('./replace.cjs');
+var replaceAll = require('./replaceAll.cjs');
+var match = require('./match.cjs');
+var matchAll = require('./matchAll.cjs');
+var concat = require('./concat.cjs');
+var slice = require('./slice.cjs');
+var padStart = require('./padStart.cjs');
+var padEnd = require('./padEnd.cjs');
+var indexOf = require('./indexOf.cjs');
+var lastIndexOf = require('./lastIndexOf.cjs');
+var repeat = require('./repeat.cjs');
+var normalize = require('./normalize.cjs');
+var test = require('./test.cjs');
+
+
+
+exports.isKeyof = isKeyof.isKeyof;
+exports.at = _default.at;
+exports.first = first.first;
+exports.last = last.last;
+exports.split = split.split;
+exports.charAt = charAt.charAt;
+exports.toUpperCase = toUpperCase.toUpperCase;
+exports.toLowerCase = toLowerCase.toLowerCase;
+exports.trim = _default$1.trim;
+exports.trimEnd = end.trimEnd;
+exports.trimStart = start.trimStart;
+exports.capitalize = capitalize.capitalize;
+exports.uncapitalize = uncapitalize.uncapitalize;
+exports.substring = substring.substring;
+exports.startsWith = startsWith.startsWith;
+exports.endsWith = endsWith.endsWith;
+exports.includes = includes.includes;
+exports.search = search.search;
+exports.replace = replace.replace;
+exports.replaceAll = replaceAll.replaceAll;
+exports.match = match.match;
+exports.matchAll = matchAll.matchAll;
+exports.concat = concat.concat;
+exports.slice = slice.slice;
+exports.padStart = padStart.padStart;
+exports.padEnd = padEnd.padEnd;
+exports.indexOf = indexOf.indexOf;
+exports.lastIndexOf = lastIndexOf.lastIndexOf;
+exports.repeat = repeat.repeat;
+exports.normalize = normalize.normalize;
+exports.test = test.test;

package/dist/string/index.d.ts

@@ -0,0 +1,28 @@
+export * from "./types";
+export * from "./isKeyof";
+export * from "./at";
+export * from "./split";
+export * from "./charAt";
+export * from "./toUpperCase";
+export * from "./toLowerCase";
+export * from "./trim";
+export * from "./capitalize";
+export * from "./uncapitalize";
+export * from "./substring";
+export * from "./startsWith";
+export * from "./endsWith";
+export * from "./includes";
+export * from "./search";
+export * from "./replace";
+export * from "./replaceAll";
+export * from "./match";
+export * from "./matchAll";
+export * from "./concat";
+export * from "./slice";
+export * from "./padStart";
+export * from "./padEnd";
+export * from "./indexOf";
+export * from "./lastIndexOf";
+export * from "./repeat";
+export * from "./normalize";
+export * from "./test";

package/dist/string/index.mjs

@@ -0,0 +1,31 @@
+export { isKeyof } from './isKeyof.mjs';
+export { at } from './at/default.mjs';
+export { first } from './at/first.mjs';
+export { last } from './at/last.mjs';
+export { split } from './split.mjs';
+export { charAt } from './charAt.mjs';
+export { toUpperCase } from './toUpperCase.mjs';
+export { toLowerCase } from './toLowerCase.mjs';
+export { trim } from './trim/default.mjs';
+export { trimEnd } from './trim/end.mjs';
+export { trimStart } from './trim/start.mjs';
+export { capitalize } from './capitalize.mjs';
+export { uncapitalize } from './uncapitalize.mjs';
+export { substring } from './substring.mjs';
+export { startsWith } from './startsWith.mjs';
+export { endsWith } from './endsWith.mjs';
+export { includes } from './includes.mjs';
+export { search } from './search.mjs';
+export { replace } from './replace.mjs';
+export { replaceAll } from './replaceAll.mjs';
+export { match } from './match.mjs';
+export { matchAll } from './matchAll.mjs';
+export { concat } from './concat.mjs';
+export { slice } from './slice.mjs';
+export { padStart } from './padStart.mjs';
+export { padEnd } from './padEnd.mjs';
+export { indexOf } from './indexOf.mjs';
+export { lastIndexOf } from './lastIndexOf.mjs';
+export { repeat } from './repeat.mjs';
+export { normalize } from './normalize.mjs';
+export { test } from './test.mjs';

package/dist/string/indexOf.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+function indexOf(...args) {
+    if (args.length === 1) {
+        const [searchString] = args;
+        return (input) => indexOf(input, searchString);
+    }
+    const [input, searchString, position] = args;
+    const result = input.indexOf(searchString, position);
+    return result === -1 ? undefined : result;
+}
+
+exports.indexOf = indexOf;

package/dist/string/indexOf.d.ts

@@ -0,0 +1,2 @@
+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/indexOf.mjs

@@ -0,0 +1,11 @@
+function indexOf(...args) {
+    if (args.length === 1) {
+        const [searchString] = args;
+        return (input) => indexOf(input, searchString);
+    }
+    const [input, searchString, position] = args;
+    const result = input.indexOf(searchString, position);
+    return result === -1 ? undefined : result;
+}
+
+export { indexOf };

package/dist/string/isKeyof.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function isKeyof(...args) {
+    if (args.length === 1) {
+        const [obj] = args;
+        return (key) => isKeyof(key, obj);
+    }
+    const [key, obj] = args;
+    return obj[key] !== undefined;
+}
+
+exports.isKeyof = isKeyof;

package/dist/string/isKeyof.d.ts

@@ -0,0 +1,3 @@
+import { type ObjectKey } from "../common/types/objectKey";
+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/isKeyof.mjs

@@ -0,0 +1,10 @@
+function isKeyof(...args) {
+    if (args.length === 1) {
+        const [obj] = args;
+        return (key) => isKeyof(key, obj);
+    }
+    const [key, obj] = args;
+    return obj[key] !== undefined;
+}
+
+export { isKeyof };