@duplojs/utils 1.3.20 → 1.3.22

package/dist/dataParser/parsers/object/omit.d.ts

@@ -1,6 +1,7 @@
 import { type MergeDefinition } from "../../../dataParser/types";
-import { type DataParserDefinitionObject, type DataParserObject } from ".";
+import { type DataParserObjectShape, type DataParserDefinitionObject, type DataParserObject } from ".";
 import { type SimplifyTopLevel, type NeverCoalescing } from "../../../common";
+export declare function omitShape(shape: DataParserObjectShape, omitObject: Partial<Record<string, true>>): DataParserObjectShape;
 export declare function omit<GenericDataParserObject extends DataParserObject, const GenericOmitObject extends Partial<Record<keyof GenericDataParserObject["definition"]["shape"], true>>, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, omitObject: GenericOmitObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: SimplifyTopLevel<Omit<GenericDataParserObject["definition"]["shape"], keyof GenericOmitObject>>;
 }>>;

package/dist/dataParser/parsers/object/omit.mjs

@@ -5,9 +5,12 @@ import { isKeyof } from '../../../string/isKeyof.mjs';
 import { entries } from '../../../object/entries.mjs';
 import { fromEntries } from '../../../object/fromEntries.mjs';
 
+function omitShape(shape, omitObject) {
+    return pipe(shape, entries, filter(([key]) => !isKeyof(key, omitObject)), fromEntries);
+}
 function omit(dataParser, omitObject, definition) {
-    const newShape = pipe(dataParser.definition.shape, entries, filter(([key]) => !isKeyof(key, omitObject)), fromEntries);
+    const newShape = omitShape(dataParser.definition.shape, omitObject);
     return object(newShape, definition);
 }
 
-export { omit };
+export { omit, omitShape };

package/dist/dataParser/parsers/object/partial.cjs

@@ -12,9 +12,13 @@ var entry = require('../../../object/entry.cjs');
 var entries = require('../../../object/entries.cjs');
 var fromEntries = require('../../../object/fromEntries.cjs');
 
+function partialShape(shape) {
+    return pipe.pipe(shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(identifier.identifier(dataParser, optional.optionalKind), when.whenIsRight(forward.forward), when$1.whenIsLeft(optional.optional), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
+}
 function partial(dataParser, definition) {
-    const newShape = pipe.pipe(dataParser.definition.shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(identifier.identifier(dataParser, optional.optionalKind), when.whenIsRight(forward.forward), when$1.whenIsLeft(optional.optional), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
+    const newShape = partialShape(dataParser.definition.shape);
     return index.object(newShape, definition);
 }
 
 exports.partial = partial;
+exports.partialShape = partialShape;

package/dist/dataParser/parsers/object/partial.d.ts

@@ -9,6 +9,7 @@ export type PartialDataParserObject<GenericShape extends DataParserObjectShape>
         coalescingValue: unknown;
     }>;
 }>;
+export declare function partialShape(shape: DataParserObjectShape): DataParserObjectShape;
 export declare function partial<GenericDataParserObject extends DataParserObject, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: PartialDataParserObject<GenericDataParserObject["definition"]["shape"]>;
 }>>;

package/dist/dataParser/parsers/object/partial.mjs

@@ -10,9 +10,12 @@ import { entry } from '../../../object/entry.mjs';
 import { entries } from '../../../object/entries.mjs';
 import { fromEntries } from '../../../object/fromEntries.mjs';
 
+function partialShape(shape) {
+    return pipe(shape, entries, map(([key, dataParser]) => pipe(identifier(dataParser, optionalKind), whenIsRight(forward), whenIsLeft(optional), (dataParser) => entry(key, dataParser))), fromEntries);
+}
 function partial(dataParser, definition) {
-    const newShape = pipe(dataParser.definition.shape, entries, map(([key, dataParser]) => pipe(identifier(dataParser, optionalKind), whenIsRight(forward), whenIsLeft(optional), (dataParser) => entry(key, dataParser))), fromEntries);
+    const newShape = partialShape(dataParser.definition.shape);
     return object(newShape, definition);
 }
 
-export { partial };
+export { partial, partialShape };

package/dist/dataParser/parsers/object/pick.cjs

@@ -7,9 +7,13 @@ var isKeyof = require('../../../string/isKeyof.cjs');
 var entries = require('../../../object/entries.cjs');
 var fromEntries = require('../../../object/fromEntries.cjs');
 
-function pick(dataParser, omitObject, definition) {
-    const newShape = pipe.pipe(dataParser.definition.shape, entries.entries, filter.filter(([key]) => isKeyof.isKeyof(key, omitObject)), fromEntries.fromEntries);
+function pickShape(shape, pickObject) {
+    return pipe.pipe(shape, entries.entries, filter.filter(([key]) => isKeyof.isKeyof(key, pickObject)), fromEntries.fromEntries);
+}
+function pick(dataParser, pickObject, definition) {
+    const newShape = pickShape(dataParser.definition.shape, pickObject);
     return index.object(newShape, definition);
 }
 
 exports.pick = pick;
+exports.pickShape = pickShape;

package/dist/dataParser/parsers/object/pick.d.ts

@@ -1,6 +1,7 @@
 import { type MergeDefinition } from "../../../dataParser/types";
-import { type DataParserDefinitionObject, type DataParserObject } from ".";
+import { type DataParserObjectShape, type DataParserDefinitionObject, type DataParserObject } from ".";
 import { type SimplifyTopLevel, type NeverCoalescing, type Adaptor } from "../../../common";
-export declare function pick<GenericDataParserObject extends DataParserObject, const GenericOmitObject extends Partial<Record<keyof GenericDataParserObject["definition"]["shape"], true>>, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, omitObject: GenericOmitObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
+export declare function pickShape(shape: DataParserObjectShape, pickObject: Partial<Record<string, true>>): DataParserObjectShape;
+export declare function pick<GenericDataParserObject extends DataParserObject, const GenericOmitObject extends Partial<Record<keyof GenericDataParserObject["definition"]["shape"], true>>, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, pickObject: GenericOmitObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: SimplifyTopLevel<Pick<GenericDataParserObject["definition"]["shape"], Adaptor<keyof GenericOmitObject, keyof GenericDataParserObject["definition"]["shape"]>>>;
 }>>;

package/dist/dataParser/parsers/object/pick.mjs

@@ -5,9 +5,12 @@ import { isKeyof } from '../../../string/isKeyof.mjs';
 import { entries } from '../../../object/entries.mjs';
 import { fromEntries } from '../../../object/fromEntries.mjs';
 
-function pick(dataParser, omitObject, definition) {
-    const newShape = pipe(dataParser.definition.shape, entries, filter(([key]) => isKeyof(key, omitObject)), fromEntries);
+function pickShape(shape, pickObject) {
+    return pipe(shape, entries, filter(([key]) => isKeyof(key, pickObject)), fromEntries);
+}
+function pick(dataParser, pickObject, definition) {
+    const newShape = pickShape(dataParser.definition.shape, pickObject);
     return object(newShape, definition);
 }
 
-export { pick };
+export { pick, pickShape };

package/dist/dataParser/parsers/object/required.cjs

@@ -12,9 +12,13 @@ var entry = require('../../../object/entry.cjs');
 var entries = require('../../../object/entries.cjs');
 var fromEntries = require('../../../object/fromEntries.cjs');
 
+function requiredShape(shape) {
+    return pipe.pipe(shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(identifier.identifier(dataParser, optional.optionalKind), when.whenIsRight((dataParser) => dataParser.definition.inner), when$1.whenIsLeft(forward.forward), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
+}
 function required(dataParser, definition) {
-    const newShape = pipe.pipe(dataParser.definition.shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(identifier.identifier(dataParser, optional.optionalKind), when.whenIsRight((dataParser) => dataParser.definition.inner), when$1.whenIsLeft(forward.forward), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
+    const newShape = requiredShape(dataParser.definition.shape);
     return index.object(newShape, definition);
 }
 
 exports.required = required;
+exports.requiredShape = requiredShape;

package/dist/dataParser/parsers/object/required.d.ts

@@ -5,6 +5,7 @@ import { type DataParserOptional } from "../optional";
 export type RequireDataParserObject<GenericShape extends DataParserObjectShape> = SimplifyTopLevel<{
     [Prop in keyof GenericShape]: GenericShape[Prop] extends DataParserOptional<any> ? GenericShape[Prop]["definition"]["inner"] : GenericShape[Prop];
 }>;
+export declare function requiredShape(shape: DataParserObjectShape): DataParserObjectShape;
 export declare function required<GenericDataParserObject extends DataParserObject, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: RequireDataParserObject<GenericDataParserObject["definition"]["shape"]>;
 }>>;

package/dist/dataParser/parsers/object/required.mjs

@@ -10,9 +10,12 @@ import { entry } from '../../../object/entry.mjs';
 import { entries } from '../../../object/entries.mjs';
 import { fromEntries } from '../../../object/fromEntries.mjs';
 
+function requiredShape(shape) {
+    return pipe(shape, entries, map(([key, dataParser]) => pipe(identifier(dataParser, optionalKind), whenIsRight((dataParser) => dataParser.definition.inner), whenIsLeft(forward), (dataParser) => entry(key, dataParser))), fromEntries);
+}
 function required(dataParser, definition) {
-    const newShape = pipe(dataParser.definition.shape, entries, map(([key, dataParser]) => pipe(identifier(dataParser, optionalKind), whenIsRight((dataParser) => dataParser.definition.inner), whenIsLeft(forward), (dataParser) => entry(key, dataParser))), fromEntries);
+    const newShape = requiredShape(dataParser.definition.shape);
     return object(newShape, definition);
 }
 
-export { required };
+export { required, requiredShape };

package/dist/dataParser/parsers/refine.cjs

@@ -4,7 +4,7 @@ var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserCheckerRefineKind = kind.createDataParserKind("checker-string-max");
+const dataParserCheckerRefineKind = kind.createDataParserKind("refine");
 function checkerRefine(theFunction, definition) {
     return base.dataParserCheckerInit(dataParserCheckerRefineKind, {
         definition: {

package/dist/dataParser/parsers/refine.d.ts

@@ -4,7 +4,7 @@ import { type AssignObjects } from "../../object";
 export interface DataParserCheckerDefinitionRefine extends DataParserCheckerDefinition {
     theFunction(input: unknown): boolean;
 }
-export declare const dataParserCheckerRefineKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-max", unknown>>;
+export declare const dataParserCheckerRefineKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/refine", unknown>>;
 type _DataParserCheckerRefine<GenericDefinition extends DataParserCheckerDefinitionRefine> = (Kind<typeof dataParserCheckerRefineKind.definition> & DataParserChecker<GenericDefinition, string>);
 export interface DataParserCheckerRefine<GenericDefinition extends DataParserCheckerDefinitionRefine = DataParserCheckerDefinitionRefine> extends _DataParserCheckerRefine<GenericDefinition> {
 }

package/dist/dataParser/parsers/refine.mjs

@@ -2,7 +2,7 @@ import { dataParserCheckerInit } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserCheckerRefineKind = createDataParserKind("checker-string-max");
+const dataParserCheckerRefineKind = createDataParserKind("refine");
 function checkerRefine(theFunction, definition) {
     return dataParserCheckerInit(dataParserCheckerRefineKind, {
         definition: {

package/dist/either/future/create.d.ts

@@ -15,7 +15,7 @@ declare const kind = "kind-future-either";
 export declare class Future<const GenericValue extends unknown = unknown> extends Promise<ComputeFutureEitherResult<GenericValue>> {
     constructor(value: GenericValue);
     [kind]: unknown;
-    then<TResult1 = ComputeFutureEitherResult<GenericValue>, TResult2 = never>(onfulfilled?: ((value: ComputeFutureEitherResult<GenericValue>) => TResult1 | PromiseLike<TResult1>) | null): Promise<TResult1 | TResult2>;
+    then<TResult1 = Extract<ComputeFutureEitherResult<GenericValue>, any>, TResult2 = never>(onfulfilled?: ((value: Extract<ComputeFutureEitherResult<GenericValue>, any>) => TResult1 | PromiseLike<TResult1>) | null): Promise<TResult1 | TResult2>;
     static get [Symbol.species](): PromiseConstructor;
     static instanceof<GenericValue extends unknown>(value: GenericValue): value is Extract<GenericValue, Future<any>>;
     static rightAll<const GenericArray extends readonly unknown[]>(values: GenericArray): FutureEitherAllResult<GenericArray>;

package/dist/generator/asyncChunk.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+function asyncChunk(...args) {
+    if (args.length === 1) {
+        const [size] = args;
+        return (input) => asyncChunk(input, size);
+    }
+    const [input, size] = args;
+    return (async function* () {
+        let buffer = [];
+        for await (const element of input) {
+            buffer.push(element);
+            if (buffer.length === size) {
+                yield buffer;
+                buffer = [];
+            }
+        }
+        if (buffer.length > 0) {
+            yield buffer;
+        }
+    })();
+}
+
+exports.asyncChunk = asyncChunk;

package/dist/generator/asyncChunk.d.ts

@@ -0,0 +1,2 @@
+export declare function asyncChunk<const GenericElement extends unknown>(size: number): (input: AsyncIterable<GenericElement>) => AsyncGenerator<GenericElement[], unknown, unknown>;
+export declare function asyncChunk<const GenericElement extends unknown>(input: AsyncIterable<GenericElement>, size: number): AsyncGenerator<GenericElement[], unknown, unknown>;

package/dist/generator/asyncChunk.mjs

@@ -0,0 +1,22 @@
+function asyncChunk(...args) {
+    if (args.length === 1) {
+        const [size] = args;
+        return (input) => asyncChunk(input, size);
+    }
+    const [input, size] = args;
+    return (async function* () {
+        let buffer = [];
+        for await (const element of input) {
+            buffer.push(element);
+            if (buffer.length === size) {
+                yield buffer;
+                buffer = [];
+            }
+        }
+        if (buffer.length > 0) {
+            yield buffer;
+        }
+    })();
+}
+
+export { asyncChunk };

package/dist/generator/asyncLoop.d.ts

@@ -1,10 +1,3 @@
-import { type AnyValue } from "../common";
-import { type GeneratorLoopParams } from "./loop";
-interface LoopOutputExistResult<GenericOutput extends any> {
-    "-exitData": GenericOutput | undefined;
-}
-interface LoopOutputNextResult<GenericOutput extends any> {
-    "-nextData": GenericOutput | undefined;
-}
-export declare function asyncLoop<GenericRawExitOutput extends AnyValue = undefined, GenericRawNextOutput extends AnyValue = undefined>(loop: (params: GeneratorLoopParams<GenericRawNextOutput>) => Promise<LoopOutputNextResult<GenericRawNextOutput> | LoopOutputNextResult<undefined> | LoopOutputExistResult<GenericRawExitOutput> | LoopOutputExistResult<undefined>>): AsyncGenerator<Exclude<GenericRawExitOutput | GenericRawNextOutput, undefined>, unknown, unknown>;
-export {};
+import { type MaybePromise } from "../common";
+import { type LoopOutputExistResult, type LoopOutputNextResult, type GeneratorLoopParams } from "./loop";
+export declare function asyncLoop<GenericRawNextOutput extends unknown, GenericOutput extends MaybePromise<LoopOutputNextResult<GenericRawNextOutput> | LoopOutputExistResult<unknown> | LoopOutputNextResult<undefined> | LoopOutputExistResult<undefined>>>(loop: (params: GeneratorLoopParams<GenericRawNextOutput>) => GenericOutput): AsyncGenerator<Exclude<Awaited<GenericOutput> extends infer InferredOutput ? InferredOutput extends LoopOutputNextResult ? InferredOutput["-nextData"] : InferredOutput extends LoopOutputExistResult ? InferredOutput["-exitData"] : never : never, undefined>, unknown, unknown>;

package/dist/generator/asyncMap.cjs

@@ -9,7 +9,7 @@ function asyncMap(...args) {
     let index = 0;
     return (async function* () {
         for await (const element of iterator) {
-            yield theFunction(element, { index });
+            yield await theFunction(element, { index });
             index++;
         }
     })();

package/dist/generator/asyncMap.d.ts

@@ -1,6 +1,6 @@
 interface AsyncGeneratorMapParams {
     index: number;
 }
-export declare function asyncMap<const GenericInput extends unknown, const GenericOutput extends unknown>(theFunction: (arg: GenericInput, params: AsyncGeneratorMapParams) => Promise<GenericOutput>): (iterator: AsyncIterable<GenericInput> | Iterable<GenericInput>) => AsyncGenerator<GenericOutput, unknown, unknown>;
-export declare function asyncMap<const GenericInput extends unknown, const GenericOutput extends unknown>(iterator: AsyncIterable<GenericInput> | Iterable<GenericInput>, theFunction: (arg: GenericInput, params: AsyncGeneratorMapParams) => Promise<GenericOutput>): AsyncGenerator<GenericOutput, unknown, unknown>;
+export declare function asyncMap<const GenericInput extends unknown, const GenericOutput extends unknown>(theFunction: (arg: GenericInput, params: AsyncGeneratorMapParams) => GenericOutput): (iterator: AsyncIterable<GenericInput> | Iterable<GenericInput>) => AsyncGenerator<Awaited<GenericOutput>, unknown, unknown>;
+export declare function asyncMap<const GenericInput extends unknown, const GenericOutput extends unknown>(iterator: AsyncIterable<GenericInput> | Iterable<GenericInput>, theFunction: (arg: GenericInput, params: AsyncGeneratorMapParams) => GenericOutput): AsyncGenerator<Awaited<GenericOutput>, unknown, unknown>;
 export {};

package/dist/generator/asyncMap.mjs

@@ -7,7 +7,7 @@ function asyncMap(...args) {
     let index = 0;
     return (async function* () {
         for await (const element of iterator) {
-            yield theFunction(element, { index });
+            yield await theFunction(element, { index });
             index++;
         }
     })();

package/dist/generator/index.cjs

@@ -10,6 +10,7 @@ var asyncReduce = require('./asyncReduce.cjs');
 var loop = require('./loop.cjs');
 var asyncLoop = require('./asyncLoop.cjs');
 var chunk = require('./chunk.cjs');
+var asyncChunk = require('./asyncChunk.cjs');
 
 
 
@@ -24,3 +25,4 @@ exports.asyncReduce = asyncReduce.asyncReduce;
 exports.loop = loop.loop;
 exports.asyncLoop = asyncLoop.asyncLoop;
 exports.chunk = chunk.chunk;
+exports.asyncChunk = asyncChunk.asyncChunk;

package/dist/generator/index.d.ts

@@ -8,3 +8,4 @@ export * from "./asyncReduce";
 export * from "./loop";
 export * from "./asyncLoop";
 export * from "./chunk";
+export * from "./asyncChunk";

package/dist/generator/index.mjs

@@ -8,3 +8,4 @@ export { asyncReduce } from './asyncReduce.mjs';
 export { loop } from './loop.mjs';
 export { asyncLoop } from './asyncLoop.mjs';
 export { chunk } from './chunk.mjs';
+export { asyncChunk } from './asyncChunk.mjs';

package/dist/generator/loop.d.ts

@@ -1,9 +1,9 @@
 import { type AnyValue } from "../common";
-interface LoopOutputExistResult<GenericOutput extends any> {
-    "-exitData": GenericOutput | undefined;
+export interface LoopOutputExistResult<GenericOutput extends unknown = unknown> {
+    "-exitData": GenericOutput;
 }
-interface LoopOutputNextResult<GenericOutput extends any> {
-    "-nextData": GenericOutput | undefined;
+export interface LoopOutputNextResult<GenericOutput extends unknown = unknown> {
+    "-nextData": GenericOutput;
 }
 export interface GeneratorLoopParams<GenericRawNextOutput extends any> {
     count: number;
@@ -12,4 +12,3 @@ export interface GeneratorLoopParams<GenericRawNextOutput extends any> {
     exit<GenericOutput extends AnyValue = undefined>(output?: GenericOutput): LoopOutputExistResult<GenericOutput>;
 }
 export declare function loop<GenericRawExitOutput extends AnyValue = undefined, GenericRawNextOutput extends AnyValue = undefined>(loop: (params: GeneratorLoopParams<GenericRawNextOutput>) => LoopOutputNextResult<GenericRawNextOutput> | LoopOutputNextResult<undefined> | LoopOutputExistResult<GenericRawExitOutput> | LoopOutputExistResult<undefined>): Generator<Exclude<GenericRawExitOutput | GenericRawNextOutput, undefined>, unknown, unknown>;
-export {};

package/dist/index.cjs

@@ -26,7 +26,7 @@ var simpleClone = require('./common/simpleClone.cjs');
 var sleep = require('./common/sleep.cjs');
 var stringToBytes = require('./common/stringToBytes.cjs');
 var stringToMillisecond = require('./common/stringToMillisecond.cjs');
-var toJson = require('./common/toJson.cjs');
+var toJSON = require('./common/toJSON.cjs');
 var toTransform = require('./common/toTransform.cjs');
 var toWrappedValue = require('./common/toWrappedValue.cjs');
 var unwrap = require('./common/unwrap.cjs');
@@ -101,7 +101,7 @@ exports.InvalidBytesInStringError = stringToBytes.InvalidBytesInStringError;
 exports.stringToBytes = stringToBytes.stringToBytes;
 exports.InvalidMillisecondInStringError = stringToMillisecond.InvalidMillisecondInStringError;
 exports.stringToMillisecond = stringToMillisecond.stringToMillisecond;
-exports.toJSON = toJson.toJSON;
+exports.toJSON = toJSON.toJSON;
 exports.toTransform = toTransform.toTransform;
 exports.toWrappedValue = toWrappedValue.toWrappedValue;
 exports.unwrap = unwrap.unwrap;

package/dist/index.mjs

@@ -48,7 +48,7 @@ export { simpleClone } from './common/simpleClone.mjs';
 export { sleep } from './common/sleep.mjs';
 export { InvalidBytesInStringError, stringToBytes } from './common/stringToBytes.mjs';
 export { InvalidMillisecondInStringError, stringToMillisecond } from './common/stringToMillisecond.mjs';
-export { toJSON } from './common/toJson.mjs';
+export { toJSON } from './common/toJSON.mjs';
 export { toTransform } from './common/toTransform.mjs';
 export { toWrappedValue } from './common/toWrappedValue.mjs';
 export { unwrap } from './common/unwrap.mjs';