@duplojs/utils 1.4.58 → 1.4.59

package/dist/array/group.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-var reduce = require('./reduce.cjs');
-
 function groupOutput(...args) {
     if (args.length === 1) {
         const [group] = args;
@@ -19,18 +17,20 @@ function group(...args) {
         return (array) => group(array, theFunction);
     }
     const [array, theFunction] = args;
-    return reduce.reduce(array, reduce.reduceFrom({}), ({ index, element, lastValue, nextWithObject }) => {
-        const { group, value } = theFunction(element, {
+    const result = {};
+    for (let index = 0; index < array.length; index++) {
+        const { group, value } = theFunction(array[index], {
             index,
             output: groupOutput,
         });
-        return nextWithObject(lastValue, {
-            [group]: [
-                ...(lastValue[group] ?? []),
-                value,
-            ],
-        });
-    });
+        if (result[group]) {
+            result[group].push(value);
+        }
+        else {
+            result[group] = [value];
+        }
+    }
+    return result;
 }
 
 exports.group = group;

package/dist/array/group.d.ts

@@ -1,4 +1,4 @@
-import { type SimplifyTopLevel } from "../common/types/simplifyTopLevel";
+import type { SimplifyTopLevel } from "../common/types/simplifyTopLevel";
 export interface ArrayGroupFunctionOutput<GenericGroupName extends string = string, GenericGroupValue extends unknown = unknown> {
     group: GenericGroupName;
     value: GenericGroupValue;

package/dist/array/group.mjs

@@ -1,5 +1,3 @@
-import { reduce, reduceFrom } from './reduce.mjs';
-
 function groupOutput(...args) {
     if (args.length === 1) {
         const [group] = args;
@@ -17,18 +15,20 @@ function group(...args) {
         return (array) => group(array, theFunction);
     }
     const [array, theFunction] = args;
-    return reduce(array, reduceFrom({}), ({ index, element, lastValue, nextWithObject }) => {
-        const { group, value } = theFunction(element, {
+    const result = {};
+    for (let index = 0; index < array.length; index++) {
+        const { group, value } = theFunction(array[index], {
             index,
             output: groupOutput,
         });
-        return nextWithObject(lastValue, {
-            [group]: [
-                ...(lastValue[group] ?? []),
-                value,
-            ],
-        });
-    });
+        if (result[group]) {
+            result[group].push(value);
+        }
+        else {
+            result[group] = [value];
+        }
+    }
+    return result;
 }
 
 export { group, groupOutput };

package/dist/common/index.d.ts

@@ -16,7 +16,7 @@
  * - predicates and guards (`when`, `whenNot`, `whenElse`, `and`, `or`, `isType`, `asserts`, `instanceOf`)
  * - control flow (`loop`, `asyncLoop`, `asyncRetry`, `sleep`, `memo`)
  * - promise utilities (`externalPromise`, `promiseObject`)
- * - string and value conversions (`stringToMillisecond`, `stringToBytes`, `escapeRegExp`)
+ * - string and value conversions (`stringToMillisecond`, `stringToBytes`, `escapeRegExp`, `toRegExp`)
  * - wrappers and kinds (`wrapValue`, `unwrap`, `toWrappedValue`, `hasKinds`, `hasSomeKinds`)
  * 
  * @see https://utils.duplojs.dev/en/v1/api/common
@@ -74,3 +74,4 @@ export * from "./pipeCall";
 export * from "./asserts";
 export * from "./path";
 export * from "./transformer";
+export * from "./toRegExp";

package/dist/common/path.cjs

@@ -1,14 +1,11 @@
 'use strict';
 
-var success = require('../either/right/success.cjs');
-var fail = require('../either/left/fail.cjs');
-
 exports.Path = void 0;
 (function (Path) {
     Path.baseNameRegex = /\/?([^/]+)$/;
     Path.folderNameRegex = /([^]+)\/[^/]+\/?$/;
     Path.extensionNameRegex = /\.([^./]+)$/;
-    Path.isRelativeRegex = /(^|\/)\.\.(?=\/|$)/;
+    Path.isContainBackPathRegex = /(^|\/)\.\.(?=\/|$)/;
     Path.segmentTrailingRegex = /\/$/;
     Path.segmentRelativeRegex = /^(.\/)/;
     /**
@@ -52,17 +49,21 @@ exports.Path = void 0;
      */
     function isAbsolute(path) {
         return path.startsWith("/")
-            && !Path.isRelativeRegex.test(path);
+            && !Path.isContainBackPathRegex.test(path);
     }
     Path.isAbsolute = isAbsolute;
     /**
      * {@include common/path/resolveFrom/index.md}
      */
-    function resolveFrom(origin, segments) {
-        const result = resolveRelative([origin, ...segments]);
+    function resolveFrom(origin, segments, params) {
+        const resultRelative = resolveRelative(segments);
+        if (params?.stayInOrigin && resultRelative.startsWith("../")) {
+            return null;
+        }
+        const result = resolveRelative([origin, resultRelative]);
         return isAbsolute(result)
-            ? success.success(result)
-            : fail.fail();
+            ? result
+            : null;
     }
     Path.resolveFrom = resolveFrom;
     /**
@@ -74,16 +75,15 @@ exports.Path = void 0;
             if (segment.length === 0) {
                 continue;
             }
-            if (segment === "/") {
+            else if (segment === "/") {
                 clearedPath = segment;
                 continue;
             }
             const formattedSegment = fix(segment);
-            if (formattedSegment.startsWith("/")) {
+            if (formattedSegment.startsWith("/") || clearedPath === "") {
                 clearedPath = formattedSegment;
-                continue;
             }
-            if (clearedPath === "/") {
+            else if (clearedPath === "/") {
                 clearedPath += formattedSegment;
             }
             else {

package/dist/common/path.d.ts

@@ -1,10 +1,9 @@
-import * as DEither from "../either";
 import type { AnyTuple } from "./types";
 export declare namespace Path {
     const baseNameRegex: RegExp;
     const folderNameRegex: RegExp;
     const extensionNameRegex: RegExp;
-    const isRelativeRegex: RegExp;
+    const isContainBackPathRegex: RegExp;
     const segmentTrailingRegex: RegExp;
     const segmentRelativeRegex: RegExp;
     interface GetBaseNameParams {
@@ -95,31 +94,38 @@ export declare namespace Path {
      * 
      */
     function isAbsolute<GenericPath extends string>(path: GenericPath): boolean;
+    interface ResolveFromParams {
+        stayInOrigin?: boolean;
+    }
     /**
-     * Resolves a list of path segments from an origin and returns an Either.
+     * Resolves a list of path segments from an origin.
      * 
      * **Supported call styles:**
-     * - Classic: `resolveFrom(origin, segments)` -> returns an Either
+     * - Classic: `resolveFrom(origin, segments, params?)` -> returns the resolved absolute path or null
      * 
      * Segments are resolved in order using `resolveRelative`.
-     * The result is an `Either` that is `success` only when the resolved path is absolute; otherwise it returns `fail`.
+     * The function returns `null` when the final path is not absolute.
+     * When `params.stayInOrigin` is `true`, the resolution returns `null` if segments escape the origin with leading `../`.
      * 
      * ```ts
      * const absoluteResult = Path.resolveFrom("/root", ["alpha", "beta"]);
-     * // absoluteResult: DEither.success<"/root/alpha/beta">
-     * const result = unwrap(absoluteResult);
-     * // result: "/root/alpha/beta"
+     * // absoluteResult: "/root/alpha/beta"
      * 
      * const overrideResult = Path.resolveFrom("gamma", ["alpha", "/root", "beta"]);
-     * // overrideResult: DEither.success<"/root/beta">
+     * // overrideResult: "/root/beta"
+     * 
      * const relativeResult = Path.resolveFrom("alpha", ["..", ".."]);
-     * // relativeResult: DEither.fail
+     * // relativeResult: null
+     * 
+     * const blockedResult = Path.resolveFrom("/root", ["..", "etc"], {
+     * 	stayInOrigin: true,
+     * });
      * ```
      * 
      * @see https://utils.duplojs.dev/en/v1/api/common/path/resolveFrom
      * 
      */
-    function resolveFrom<GenericSegment extends string>(origin: string, segments: AnyTuple<GenericSegment>): DEither.Fail | DEither.Success<string>;
+    function resolveFrom<GenericSegment extends string>(origin: string, segments: AnyTuple<GenericSegment>, params?: ResolveFromParams): string | null;
     /**
      * Resolves path segments into a single POSIX-like path.
      * 

package/dist/common/path.mjs

@@ -1,12 +1,9 @@
-import { success } from '../either/right/success.mjs';
-import { fail } from '../either/left/fail.mjs';
-
 var Path;
 (function (Path) {
     Path.baseNameRegex = /\/?([^/]+)$/;
     Path.folderNameRegex = /([^]+)\/[^/]+\/?$/;
     Path.extensionNameRegex = /\.([^./]+)$/;
-    Path.isRelativeRegex = /(^|\/)\.\.(?=\/|$)/;
+    Path.isContainBackPathRegex = /(^|\/)\.\.(?=\/|$)/;
     Path.segmentTrailingRegex = /\/$/;
     Path.segmentRelativeRegex = /^(.\/)/;
     /**
@@ -50,17 +47,21 @@ var Path;
      */
     function isAbsolute(path) {
         return path.startsWith("/")
-            && !Path.isRelativeRegex.test(path);
+            && !Path.isContainBackPathRegex.test(path);
     }
     Path.isAbsolute = isAbsolute;
     /**
      * {@include common/path/resolveFrom/index.md}
      */
-    function resolveFrom(origin, segments) {
-        const result = resolveRelative([origin, ...segments]);
+    function resolveFrom(origin, segments, params) {
+        const resultRelative = resolveRelative(segments);
+        if (params?.stayInOrigin && resultRelative.startsWith("../")) {
+            return null;
+        }
+        const result = resolveRelative([origin, resultRelative]);
         return isAbsolute(result)
-            ? success(result)
-            : fail();
+            ? result
+            : null;
     }
     Path.resolveFrom = resolveFrom;
     /**
@@ -72,16 +73,15 @@ var Path;
             if (segment.length === 0) {
                 continue;
             }
-            if (segment === "/") {
+            else if (segment === "/") {
                 clearedPath = segment;
                 continue;
             }
             const formattedSegment = fix(segment);
-            if (formattedSegment.startsWith("/")) {
+            if (formattedSegment.startsWith("/") || clearedPath === "") {
                 clearedPath = formattedSegment;
-                continue;
             }
-            if (clearedPath === "/") {
+            else if (clearedPath === "/") {
                 clearedPath += formattedSegment;
             }
             else {

package/dist/common/toRegExp.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var escapeRegExp = require('./escapeRegExp.cjs');
+
+/**
+ * {@include common/toRegExp/index.md}
+ */
+function toRegExp(input) {
+    if (typeof input === "string") {
+        return new RegExp(`^${escapeRegExp.escapeRegExp(input)}$`);
+    }
+    if (Array.isArray(input)) {
+        const result = input.map(escapeRegExp.escapeRegExp).join("|");
+        return new RegExp(`^(?:${result})$`);
+    }
+    return input;
+}
+
+exports.toRegExp = toRegExp;

package/dist/common/toRegExp.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The toRegExp() function normalizes a value into a regular expression. Strings and string arrays are escaped and converted to exact-match regex patterns.
+ * 
+ * Supported call style:
+ * - Classic: `toRegExp(input)` → returns a value
+ * 
+ * Behavior:
+ * - `string` input becomes an exact regex (`^.../**
+)
+ * - `string[]` input becomes an exact alternation regex (`^(?:...|...)/**
+)
+ * - `RegExp` input is returned as-is
+ * 
+ * ```ts
+ * const fromString = toRegExp("a.c");
+ * // matches only the literal "a.c"
+ * 
+ * const fromList = toRegExp([
+ * 	"jpg",
+ * 	"png",
+ * ]);
+ * // matches "jpg" or "png"
+ * 
+ * const existing = /hello/i;
+ * const sameInstance = toRegExp(existing);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/toRegExp
+ * 
+ */
+export declare function toRegExp(input: string | string[] | RegExp): RegExp;

package/dist/common/toRegExp.mjs

@@ -0,0 +1,17 @@
+import { escapeRegExp } from './escapeRegExp.mjs';
+
+/**
+ * {@include common/toRegExp/index.md}
+ */
+function toRegExp(input) {
+    if (typeof input === "string") {
+        return new RegExp(`^${escapeRegExp(input)}$`);
+    }
+    if (Array.isArray(input)) {
+        const result = input.map(escapeRegExp).join("|");
+        return new RegExp(`^(?:${result})$`);
+    }
+    return input;
+}
+
+export { toRegExp };

package/dist/dataParser/error.cjs

@@ -15,19 +15,21 @@ function createError() {
         currentPath: [],
     });
 }
-function addIssue(error, source, data) {
+function addIssue(error, source, data, moreInformation) {
     error.issues.push(errorIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
+        moreInformation,
     }));
     return error;
 }
-function addPromiseIssue(error, source, data) {
+function addPromiseIssue(error, source, data, moreInformation) {
     error.issues.push(errorPromiseIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
+        moreInformation,
     }));
     return error;
 }

package/dist/dataParser/error.d.ts

@@ -10,6 +10,7 @@ export interface DataParserErrorIssue extends Kind<typeof errorIssueKind.definit
     readonly source: DataParser | DataParserCheckers;
     readonly path: string;
     readonly data: unknown;
+    readonly moreInformation?: string;
 }
 export declare const SymbolDataParserErrorPromiseIssueLabel = "SymbolDataParserErrorPromiseIssue";
 export declare const SymbolDataParserErrorPromiseIssue: unique symbol;
@@ -19,6 +20,7 @@ export interface DataParserErrorPromiseIssue extends Kind<typeof errorPromiseIss
     readonly source: DataParserTransform;
     readonly path: string;
     readonly data: unknown;
+    readonly moreInformation?: string;
 }
 export declare const errorKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/error", unknown>>;
 export interface DataParserError extends Kind<typeof errorKind.definition> {
@@ -26,7 +28,7 @@ export interface DataParserError extends Kind<typeof errorKind.definition> {
     readonly currentPath: string[];
 }
 export declare function createError(): DataParserError;
-export declare function addIssue(error: DataParserError, source: DataParser | DataParserCheckers, data: unknown): DataParserError;
-export declare function addPromiseIssue(error: DataParserError, source: DataParserTransform, data: unknown): DataParserError;
+export declare function addIssue(error: DataParserError, source: DataParser | DataParserCheckers, data: unknown, moreInformation?: string): DataParserError;
+export declare function addPromiseIssue(error: DataParserError, source: DataParserTransform, data: unknown, moreInformation?: string): DataParserError;
 export declare function setErrorPath(error: DataParserError, value: string, index: number): DataParserError;
 export declare function popErrorPath(error: DataParserError): DataParserError;

package/dist/dataParser/error.mjs

@@ -13,19 +13,21 @@ function createError() {
         currentPath: [],
     });
 }
-function addIssue(error, source, data) {
+function addIssue(error, source, data, moreInformation) {
     error.issues.push(errorIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
+        moreInformation,
     }));
     return error;
 }
-function addPromiseIssue(error, source, data) {
+function addPromiseIssue(error, source, data, moreInformation) {
     error.issues.push(errorPromiseIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
+        moreInformation,
     }));
     return error;
 }

package/dist/generator/asyncGroup.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var group = require('./group.cjs');
+
+function asyncGroup(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (asyncIterator) => asyncGroup(asyncIterator, theFunction);
+    }
+    const [asyncIterator, theFunction] = args;
+    const result = {};
+    let index = 0;
+    return (async () => {
+        for await (const element of asyncIterator) {
+            const { group: group$1, value } = await theFunction(element, {
+                index,
+                output: group.groupOutput,
+            });
+            if (result[group$1]) {
+                result[group$1].push(value);
+            }
+            else {
+                result[group$1] = [value];
+            }
+            index++;
+        }
+        return result;
+    })();
+}
+
+exports.asyncGroup = asyncGroup;

package/dist/generator/asyncGroup.d.ts

@@ -0,0 +1,39 @@
+import type { MaybePromise } from "../common";
+import { type GroupFunctionOutput, type GroupFunctionParams, type GroupResult } from "./group";
+/**
+ * Groups elements from an async iterable into an object by a group name.
+ * 
+ * **Supported call styles:**
+ * - Classic: `asyncGroup(asyncIterator, theFunction)` → returns a promise of grouped object
+ * - Curried: `asyncGroup(theFunction)` → returns a function waiting for the async iterator
+ * 
+ * Behavior:
+ * - The function receives `(element, { index, output })`
+ * - `theFunction` can return a value or a promise of value
+ * - `output` is `groupOutput` and returns `{ group, value }`
+ * - The input async iterator is not mutated
+ * 
+ * ```ts
+ * const asyncValues = (async function *() {
+ * 	yield Promise.resolve(1);
+ * 	yield 2;
+ * 	yield 3;
+ * 	yield 4;
+ * })();
+ * 
+ * await G.asyncGroup(
+ * 	asyncValues,
+ * 	(value, { output }) => output(value % 2 ? "odd" : "even", value),
+ * );
+ * // { odd: [1, 3], even: [2, 4] }
+ * ```
+ * 
+ * @see [`G.group`](https://utils.duplojs.dev/en/v1/api/generator/group) For sync iterables
+ * @see [`G.groupOutput`](https://utils.duplojs.dev/en/v1/api/generator/groupOutput) For creating group outputs
+ * @see https://utils.duplojs.dev/en/v1/api/generator/asyncGroup
+ * 
+ * @namespace G
+ * 
+ */
+export declare function asyncGroup<GenericElement extends unknown, GenericOutput extends GroupFunctionOutput>(theFunction: (element: GenericElement, params: GroupFunctionParams) => MaybePromise<GenericOutput>): (asyncIterator: AsyncIterable<GenericElement>) => Promise<GroupResult<GenericOutput>>;
+export declare function asyncGroup<GenericElement extends unknown, GenericOutput extends GroupFunctionOutput>(asyncIterator: AsyncIterable<GenericElement>, theFunction: (element: GenericElement, params: GroupFunctionParams) => MaybePromise<GenericOutput>): Promise<GroupResult<GenericOutput>>;

package/dist/generator/asyncGroup.mjs

@@ -0,0 +1,29 @@
+import { groupOutput } from './group.mjs';
+
+function asyncGroup(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (asyncIterator) => asyncGroup(asyncIterator, theFunction);
+    }
+    const [asyncIterator, theFunction] = args;
+    const result = {};
+    let index = 0;
+    return (async () => {
+        for await (const element of asyncIterator) {
+            const { group, value } = await theFunction(element, {
+                index,
+                output: groupOutput,
+            });
+            if (result[group]) {
+                result[group].push(value);
+            }
+            else {
+                result[group] = [value];
+            }
+            index++;
+        }
+        return result;
+    })();
+}
+
+export { asyncGroup };

package/dist/generator/group.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+function groupOutput(...args) {
+    if (args.length === 1) {
+        const [group] = args;
+        return (input) => groupOutput(group, input);
+    }
+    const [group, value] = args;
+    return {
+        group,
+        value,
+    };
+}
+function group(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (iterator) => group(iterator, theFunction);
+    }
+    const [iterator, theFunction] = args;
+    const result = {};
+    let index = 0;
+    for (const element of iterator) {
+        const { group, value } = theFunction(element, {
+            index,
+            output: groupOutput,
+        });
+        if (result[group]) {
+            result[group].push(value);
+        }
+        else {
+            result[group] = [value];
+        }
+        index++;
+    }
+    return result;
+}
+
+exports.group = group;
+exports.groupOutput = groupOutput;

package/dist/generator/group.d.ts

@@ -0,0 +1,101 @@
+import type { SimplifyTopLevel } from "../common";
+export interface GroupFunctionOutput<GenericGroupName extends string = string, GenericGroupValue extends unknown = unknown> {
+    group: GenericGroupName;
+    value: GenericGroupValue;
+}
+/**
+ * Creates a group output object for `group` and `asyncGroup`.
+ * 
+ * **Supported call styles:**
+ * - Classic: `groupOutput(group, value)` → returns a group output
+ * - Curried: `groupOutput(group)` → returns a function waiting for the value
+ * 
+ * Behavior:
+ * - The returned object always has `{ group, value }`
+ * - The `group` name is preserved as a string literal when possible
+ * 
+ * ```ts
+ * G.groupOutput(
+ * 	"even",
+ * 	2,
+ * ); // { group: "even", value: 2 }
+ * 
+ * pipe(
+ * 	"alpha",
+ * 	G.groupOutput("word"),
+ * ); // { group: "word", value: "alpha" }
+ * 
+ * G.groupOutput(
+ * 	"status",
+ * 	{
+ * 		ok: true,
+ * 	},
+ * ); // { group: "status", value: { ok: true } }
+ * ```
+ * 
+ * @see [`G.group`](https://utils.duplojs.dev/en/v1/api/generator/group) For grouping sync iterables
+ * @see [`G.asyncGroup`](https://utils.duplojs.dev/en/v1/api/generator/asyncGroup) For grouping async iterables
+ * @see https://utils.duplojs.dev/en/v1/api/generator/groupOutput
+ * 
+ * @namespace G
+ * 
+ */
+export declare function groupOutput<const GenericGroupName extends string, GenericGroupValue extends unknown>(group: GenericGroupName): (value: GenericGroupValue) => GroupFunctionOutput<GenericGroupName, GenericGroupValue>;
+export declare function groupOutput<const GenericGroupName extends string, GenericGroupValue extends unknown>(group: GenericGroupName, value: GenericGroupValue): GroupFunctionOutput<GenericGroupName, GenericGroupValue>;
+export interface GroupFunctionParams {
+    index: number;
+    output: typeof groupOutput;
+}
+export type GroupResult<GenericOutput extends GroupFunctionOutput> = SimplifyTopLevel<{
+    [Output in GenericOutput as Output["group"]]?: Output["value"][];
+}>;
+/**
+ * Groups elements from an iterable into an object by a group name.
+ * 
+ * **Supported call styles:**
+ * - Classic: `group(iterator, theFunction)` → returns a grouped object
+ * - Curried: `group(theFunction)` → returns a function waiting for the iterator
+ * 
+ * Behavior:
+ * - The function receives `(element, { index, output })`
+ * - `output` is `groupOutput` and returns `{ group, value }`
+ * - The input iterator is not mutated
+ * 
+ * ```ts
+ * G.group(
+ * 	[1, 2, 3, 4],
+ * 	(value, { output }) => output(value % 2 ? "odd" : "even", value),
+ * );
+ * // { odd: [1, 3], even: [2, 4] }
+ * 
+ * pipe(
+ * 	new Set(["alpha", "beta", "gamma"]),
+ * 	G.group((value, { index, output }) => output(
+ * 		"entry",
+ * 		{
+ * 			index,
+ * 			value,
+ * 		},
+ * 	)),
+ * );
+ * // { entry: [{ index: 0, value: "alpha" }, ...] }
+ * 
+ * G.group(
+ * 	["apple", "pear", "plum"],
+ * 	(value, { output }) => output(
+ * 		value.startsWith("p") ? "startsWithP" : "other",
+ * 		value.length,
+ * 	),
+ * );
+ * // { startsWithP: [5, 4, 4] }
+ * ```
+ * 
+ * @see [`G.groupOutput`](https://utils.duplojs.dev/en/v1/api/generator/groupOutput) For creating group outputs
+ * @see [`G.asyncGroup`](https://utils.duplojs.dev/en/v1/api/generator/asyncGroup) For async iterables
+ * @see https://utils.duplojs.dev/en/v1/api/generator/group
+ * 
+ * @namespace G
+ * 
+ */
+export declare function group<GenericElement extends unknown, GenericOutput extends GroupFunctionOutput>(theFunction: (element: GenericElement, params: GroupFunctionParams) => GenericOutput): (iterator: Iterable<GenericElement>) => GroupResult<GenericOutput>;
+export declare function group<GenericElement extends unknown, GenericOutput extends GroupFunctionOutput>(iterator: Iterable<GenericElement>, theFunction: (element: GenericElement, params: GroupFunctionParams) => GenericOutput): GroupResult<GenericOutput>;

package/dist/generator/group.mjs

@@ -0,0 +1,36 @@
+function groupOutput(...args) {
+    if (args.length === 1) {
+        const [group] = args;
+        return (input) => groupOutput(group, input);
+    }
+    const [group, value] = args;
+    return {
+        group,
+        value,
+    };
+}
+function group(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (iterator) => group(iterator, theFunction);
+    }
+    const [iterator, theFunction] = args;
+    const result = {};
+    let index = 0;
+    for (const element of iterator) {
+        const { group, value } = theFunction(element, {
+            index,
+            output: groupOutput,
+        });
+        if (result[group]) {
+            result[group].push(value);
+        }
+        else {
+            result[group] = [value];
+        }
+        index++;
+    }
+    return result;
+}
+
+export { group, groupOutput };

package/dist/generator/index.cjs

@@ -11,6 +11,8 @@ var loop = require('./loop.cjs');
 var asyncLoop = require('./asyncLoop.cjs');
 var chunk = require('./chunk.cjs');
 var asyncChunk = require('./asyncChunk.cjs');
+var group = require('./group.cjs');
+var asyncGroup = require('./asyncGroup.cjs');
 
 /**
  * {@include generator/index.md}
@@ -28,3 +30,6 @@ exports.loop = loop.loop;
 exports.asyncLoop = asyncLoop.asyncLoop;
 exports.chunk = chunk.chunk;
 exports.asyncChunk = asyncChunk.asyncChunk;
+exports.group = group.group;
+exports.groupOutput = group.groupOutput;
+exports.asyncGroup = asyncGroup.asyncGroup;

package/dist/generator/index.d.ts

@@ -17,6 +17,7 @@
  * - reduce helpers (`G.reduceFrom`)
  * - control and execution (`G.loop`, `G.execute`)
  * - batching (`G.chunk`)
+ * - grouping (`G.group`, `G.groupOutput`, `G.asyncGroup`)
  * - async variants (`G.asyncMap`, `G.asyncFilter`, `G.asyncReduce`, `G.asyncLoop`, `G.asyncChunk`)
  * 
  * @see https://utils.duplojs.dev/en/v1/api/generator
@@ -35,3 +36,5 @@ export * from "./loop";
 export * from "./asyncLoop";
 export * from "./chunk";
 export * from "./asyncChunk";
+export * from "./group";
+export * from "./asyncGroup";

package/dist/generator/index.mjs

@@ -9,6 +9,8 @@ export { loop } from './loop.mjs';
 export { asyncLoop } from './asyncLoop.mjs';
 export { chunk } from './chunk.mjs';
 export { asyncChunk } from './asyncChunk.mjs';
+export { group, groupOutput } from './group.mjs';
+export { asyncGroup } from './asyncGroup.mjs';
 
 /**
  * {@include generator/index.md}

package/dist/index.cjs

@@ -63,6 +63,7 @@ var pipeCall = require('./common/pipeCall.cjs');
 var asserts = require('./common/asserts.cjs');
 var path = require('./common/path.cjs');
 var transformer = require('./common/transformer.cjs');
+var toRegExp = require('./common/toRegExp.cjs');
 
 
 
@@ -160,3 +161,4 @@ exports.createTransformer = transformer.createTransformer;
 exports.toJSON = transformer.toJSON;
 exports.toNative = transformer.toNative;
 exports.transformer = transformer.transformer;
+exports.toRegExp = toRegExp.toRegExp;

package/dist/index.mjs

@@ -85,3 +85,4 @@ export { pipeCall } from './common/pipeCall.mjs';
 export { AssertsError, asserts } from './common/asserts.mjs';
 export { Path } from './common/path.mjs';
 export { createTransformer, toJSON, toNative, transformer } from './common/transformer.mjs';
+export { toRegExp } from './common/toRegExp.mjs';

package/dist/metadata.json

@@ -1559,6 +1559,15 @@
         {
           "name": "toCurriedPredicate.mjs"
         },
+        {
+          "name": "toRegExp.cjs"
+        },
+        {
+          "name": "toRegExp.d.ts"
+        },
+        {
+          "name": "toRegExp.mjs"
+        },
         {
           "name": "toWrappedValue.cjs"
         },
@@ -3840,6 +3849,15 @@
         {
           "name": "asyncFilter.mjs"
         },
+        {
+          "name": "asyncGroup.cjs"
+        },
+        {
+          "name": "asyncGroup.d.ts"
+        },
+        {
+          "name": "asyncGroup.mjs"
+        },
         {
           "name": "asyncLoop.cjs"
         },
@@ -3894,6 +3912,15 @@
         {
           "name": "filter.mjs"
         },
+        {
+          "name": "group.cjs"
+        },
+        {
+          "name": "group.d.ts"
+        },
+        {
+          "name": "group.mjs"
+        },
         {
           "name": "index.cjs"
         },

package/dist/object/entries.cjs

@@ -7,8 +7,13 @@ var kind = require('../common/kind.cjs');
  * {@include object/entries/index.md}
  */
 function entries(object) {
-    return Object.entries(object)
-        .filter(([key]) => !wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key));
+    const result = [];
+    for (const key in object) {
+        if (!wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key)) {
+            result.push([key, object[key]]);
+        }
+    }
+    return result;
 }
 /**
  * @deprecated Not ignore kind key.

package/dist/object/entries.mjs

@@ -5,8 +5,13 @@ import { isRuntimeKind } from '../common/kind.mjs';
  * {@include object/entries/index.md}
  */
 function entries(object) {
-    return Object.entries(object)
-        .filter(([key]) => !isRuntimeWrappedValueKey(key) && !isRuntimeKind(key));
+    const result = [];
+    for (const key in object) {
+        if (!isRuntimeWrappedValueKey(key) && !isRuntimeKind(key)) {
+            result.push([key, object[key]]);
+        }
+    }
+    return result;
 }
 /**
  * @deprecated Not ignore kind key.

package/dist/object/keys.cjs

@@ -7,8 +7,13 @@ var kind = require('../common/kind.cjs');
  * {@include object/keys/index.md}
  */
 function keys(object) {
-    return Object.keys(object)
-        .filter((key) => !wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key));
+    const result = [];
+    for (const key in object) {
+        if (!wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key)) {
+            result.push(key);
+        }
+    }
+    return result;
 }
 
 exports.keys = keys;

package/dist/object/keys.d.ts

@@ -31,4 +31,4 @@
  * @namespace O
  * 
  */
-export declare function keys<GenericObject extends object>(object: GenericObject): (Exclude<keyof GenericObject, symbol>)[];
+export declare function keys<GenericObject extends object>(object: GenericObject): (`${Exclude<keyof GenericObject, symbol>}`)[];

package/dist/object/keys.mjs

@@ -5,8 +5,13 @@ import { isRuntimeKind } from '../common/kind.mjs';
  * {@include object/keys/index.md}
  */
 function keys(object) {
-    return Object.keys(object)
-        .filter((key) => !isRuntimeWrappedValueKey(key) && !isRuntimeKind(key));
+    const result = [];
+    for (const key in object) {
+        if (!isRuntimeWrappedValueKey(key) && !isRuntimeKind(key)) {
+            result.push(key);
+        }
+    }
+    return result;
 }
 
 export { keys };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.4.58",
+  "version": "1.4.59",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"