feathers-utils 10.2.0 → 10.3.0

package/dist/{utils-BAIcSl7u.mjs → utils-DByCpAsf.mjs}

@@ -1,6 +1,6 @@
-import { r as toArray } from "./internal.utils-BMzV_-xp.mjs";
-import { d as isPaginated, m as isContext, p as isMulti } from "./predicates-puYa4nkf.mjs";
-import { a as getResultIsArray, o as getDataIsArray } from "./mutate-result.util-Dqzepn1M.mjs";
+import { a as isEmptyObject, r as toArray } from "./internal.utils-BBB-b6Ud.mjs";
+import { d as isPaginated, m as isContext, p as isMulti } from "./predicates-NOnUyMic.mjs";
+import { a as getResultIsArray, o as getDataIsArray } from "./mutate-result.util-C0nY6L7i.mjs";
 import { dequal } from "dequal";
 import * as feathers from "@feathersjs/feathers";
 //#region src/utils/sort-query-properties/sort-query-properties.util.ts
@@ -89,58 +89,13 @@ const addSkip = (context, hooks) => {
 	}
 };
 //#endregion
-//#region src/utils/chunk-find/chunk-find.util.ts
-/**
-* Use `for await` to iterate over chunks (pages) of results from a `find` method.
-*
-* This function is useful for processing large datasets in batches without loading everything into memory at once.
-* It uses pagination to fetch results in chunks, yielding each page's data array.
-*
-* @example
-* ```ts
-* import { chunkFind } from 'feathers-utils/utils'
-*
-* const app = feathers()
-*
-* // Assuming 'users' service has many records
-* for await (const users of chunkFind(app, 'users', {
-*  params: { query: { active: true }, // Custom query parameters
-* } })) {
-*  console.log(users) // Process each chunk of user records
-* }
-* ```
-*
-* @see https://utils.feathersjs.com/utils/chunk-find.html
-*/
-async function* chunkFind(app, servicePath, options) {
-	const service = app.service(servicePath);
-	if (!service || !("find" in service)) throw new Error(`Service '${servicePath}' does not have a 'find' method.`);
-	const params = {
-		...options?.params,
-		query: {
-			...options?.params?.query ?? {},
-			$limit: options?.params?.query?.$limit ?? 10,
-			$skip: options?.params?.query?.$skip ?? 0
-		},
-		paginate: {
-			default: options?.params?.paginate?.default ?? 10,
-			max: options?.params?.paginate?.max ?? 100
-		}
-	};
-	let result;
-	do {
-		result = await service.find(params);
-		if (!result.data.length) break;
-		yield result.data;
-		params.query.$skip = (params.query.$skip ?? 0) + result.data.length;
-	} while (result.total > params.query.$skip);
-}
-//#endregion
 //#region src/utils/add-to-query/add-to-query.util.ts
 /**
 * Safely merges properties into a Feathers query object. If a property already exists
 * with a different value, it wraps both in a `$and` array to preserve both conditions.
-* If the exact same key-value pair already exists, no changes are made.
+* If the exact same key-value pair already exists, no changes are made. When the added
+* query is itself a pure `$and` (`{ $and: [...] }`), its branches are flattened into the
+* target's `$and` rather than nested.
 *
 * @example
 * ```ts
@@ -165,6 +120,15 @@ function addToQuery(targetQuery, query) {
 		return entries.every(([property, value]) => property in targetQuery && dequal(targetQuery[property], value));
 	}
 	if (isAlreadyInQuery(targetQuery, entries)) return targetQuery;
+	if (entries.length === 1 && Array.isArray(query.$and)) {
+		const existing = targetQuery.$and ?? [];
+		const newBranches = query.$and.filter((branch) => !existing.some((q) => dequal(q, branch)));
+		if (newBranches.length === 0) return targetQuery;
+		return {
+			...targetQuery,
+			$and: [...existing, ...newBranches]
+		};
+	}
 	if (!targetQuery.$and) return {
 		...targetQuery,
 		$and: [{ ...query }]
@@ -200,6 +164,53 @@ function checkContext(context, typeOrOptions, methods, label = "anonymous") {
 	}
 }
 //#endregion
+//#region src/utils/chunk-find/chunk-find.util.ts
+/**
+* Use `for await` to iterate over chunks (pages) of results from a `find` method.
+*
+* This function is useful for processing large datasets in batches without loading everything into memory at once.
+* It uses pagination to fetch results in chunks, yielding each page's data array.
+*
+* @example
+* ```ts
+* import { chunkFind } from 'feathers-utils/utils'
+*
+* const app = feathers()
+*
+* // Assuming 'users' service has many records
+* for await (const users of chunkFind(app, 'users', {
+*  params: { query: { active: true }, // Custom query parameters
+* } })) {
+*  console.log(users) // Process each chunk of user records
+* }
+* ```
+*
+* @see https://utils.feathersjs.com/utils/chunk-find.html
+*/
+async function* chunkFind(app, servicePath, options) {
+	const service = app.service(servicePath);
+	if (!service || !("find" in service)) throw new Error(`Service '${servicePath}' does not have a 'find' method.`);
+	const params = {
+		...options?.params,
+		query: {
+			...options?.params?.query ?? {},
+			$limit: options?.params?.query?.$limit ?? 10,
+			$skip: options?.params?.query?.$skip ?? 0
+		},
+		paginate: {
+			default: options?.params?.paginate?.default ?? 10,
+			max: options?.params?.paginate?.max ?? 100
+		}
+	};
+	let result;
+	do {
+		result = await service.find(params);
+		if (!result.data.length) break;
+		yield result.data;
+		params.query.$skip = (params.query.$skip ?? 0) + result.data.length;
+	} while (result.total > params.query.$skip);
+}
+//#endregion
 //#region src/utils/context-to-json/context-to-json.util.ts
 /**
 * Converts a FeathersJS HookContext to a plain JSON object by calling `toJSON()` if available.
@@ -315,6 +326,172 @@ async function* iterateFind(app, servicePath, options) {
 	} while (result.total > params.query.$skip);
 }
 //#endregion
+//#region src/utils/merge-query/extract-query-filters.ts
+/**
+* Splits a query into its special filters ($select, $limit, $skip, $sort) and the
+* remaining query body. Internal helper for {@link mergeQuery} — not part of the
+* public API.
+*/
+function extractQueryFilters(providedQuery) {
+	providedQuery ??= {};
+	const { $select, $limit, $skip, $sort, ...query } = providedQuery;
+	const result = { query };
+	if ("$select" in providedQuery) result.$select = $select;
+	if ("$limit" in providedQuery) result.$limit = $limit;
+	if ("$skip" in providedQuery) result.$skip = $skip;
+	if ("$sort" in providedQuery) result.$sort = $sort;
+	return result;
+}
+//#endregion
+//#region src/utils/merge-query/logical-branches.ts
+/**
+* Returns the branches of a logical-only query (a query whose single key is `op`),
+* or `null` when the query is not purely `{ [op]: [...] }`. Internal helper for
+* {@link mergeQuery}.
+*/
+function logicalBranches(query, op) {
+	const keys = Object.keys(query);
+	if (keys.length === 1 && keys[0] === op && Array.isArray(query[op])) return query[op];
+	return null;
+}
+//#endregion
+//#region src/utils/merge-query/dedupe-branches.ts
+/**
+* Removes empty (`{}`) and deep-equal duplicate branches, preserving order.
+* Internal helper for {@link mergeQuery}.
+*/
+function dedupeBranches(branches) {
+	const result = [];
+	for (const branch of branches) {
+		if (isEmptyObject(branch)) continue;
+		if (!result.some((existing) => dequal(existing, branch))) result.push(branch);
+	}
+	return result;
+}
+//#endregion
+//#region src/utils/merge-query/has-conflict.ts
+/**
+* Two query bodies conflict when they share at least one key whose values are not
+* deep-equal. Internal helper for {@link mergeQuery}.
+*/
+function hasConflict(target, source) {
+	for (const key of Object.keys(target)) if (key in source && !dequal(target[key], source[key])) return true;
+	return false;
+}
+//#endregion
+//#region src/utils/merge-query/merge-query-bodies.ts
+/**
+* Merges two query bodies (filters already removed) according to the mode.
+* Internal helper for {@link mergeQuery}.
+*
+* - `target` / `source`: precedence merge (that side wins on conflict).
+* - `combine`: the two bodies always become branches of a single `$or`.
+* - `intersect`: non-conflicting bodies merge flat; on conflict they become
+*   branches of a single `$and`.
+*
+* Logical-only bodies (`{ $or: [...] }` for combine, `{ $and: [...] }` for
+* intersect) are flattened into the result and their branches de-duplicated.
+*/
+function mergeQueryBodies(target, source, mode) {
+	if (mode === "target") return {
+		...source,
+		...target
+	};
+	if (mode === "source") return {
+		...target,
+		...source
+	};
+	if (isEmptyObject(target)) return { ...source };
+	if (isEmptyObject(source)) return { ...target };
+	const op = mode === "combine" ? "$or" : "$and";
+	const targetBranches = logicalBranches(target, op);
+	const sourceBranches = logicalBranches(source, op);
+	if (op === "$and" && !targetBranches && !sourceBranches && !hasConflict(target, source)) return {
+		...target,
+		...source
+	};
+	const branches = dedupeBranches([...targetBranches ?? [target], ...sourceBranches ?? [source]]);
+	if (branches.length === 0) return {};
+	if (branches.length === 1) return { ...branches[0] };
+	return { [op]: branches };
+}
+//#endregion
+//#region src/utils/merge-query/merge-select.ts
+/**
+* Merges two `$select` filters according to the mode: `combine` → union,
+* `intersect` → intersection, `target`/`source` → that side. When only one side
+* provides a `$select`, that one is used. Internal helper for {@link mergeQuery}.
+*/
+function mergeSelect(target, source, mode) {
+	if (target === void 0) return source;
+	if (source === void 0) return target;
+	if (mode === "target") return target;
+	if (mode === "source") return source;
+	const targetArr = Array.isArray(target) ? target : [target];
+	const sourceArr = Array.isArray(source) ? source : [source];
+	if (mode === "combine") return [...new Set([...targetArr, ...sourceArr])];
+	return targetArr.filter((value) => sourceArr.includes(value));
+}
+//#endregion
+//#region src/utils/merge-query/merge-query.util.ts
+/**
+* Properties are combined with a logical operator rather than merged at the value
+* level, so the result is always a valid query: `combine` always wraps the two
+* queries in `$or` (broaden — OR has no flat form), while `intersect` merges
+* non-conflicting properties flat and wraps conflicts in `$and` (narrow). The
+* special filters `$select`, `$limit`, `$skip` and `$sort` are merged separately.
+* Inputs are never mutated.
+*
+* This is well suited to merging a client-provided query with a server-side
+* restriction inside a hook.
+*
+* @param target Query to be merged into
+* @param source Query to be merged from
+* @param options
+* @returns the merged query
+*
+* @example
+* ```ts
+* import { mergeQuery } from 'feathers-utils/utils'
+*
+* // combine (default): the two queries always become an $or
+* mergeQuery({ id: 1 }, { id: 2 })
+* // => { $or: [{ id: 1 }, { id: 2 }] }
+*
+* mergeQuery({ status: 'active' }, { authorId: 5 })
+* // => { $or: [{ status: 'active' }, { authorId: 5 }] }
+* ```
+*
+* @example
+* ```ts
+* // intersect: non-conflicting properties merge flat, conflicts become an $and
+* mergeQuery({ status: 'active' }, { authorId: 5 }, { mode: 'intersect' })
+* // => { status: 'active', authorId: 5 }
+*
+* mergeQuery({ id: 1 }, { id: 2 }, { mode: 'intersect' })
+* // => { $and: [{ id: 1 }, { id: 2 }] }
+* ```
+*
+* @see https://utils.feathersjs.com/utils/merge-query.html
+*/
+function mergeQuery(target, source, options) {
+	const mode = options?.mode ?? "combine";
+	const targetFilters = extractQueryFilters(target);
+	const sourceFilters = extractQueryFilters(source);
+	const result = mergeQueryBodies(targetFilters.query, sourceFilters.query, mode);
+	const $select = mergeSelect(targetFilters.$select, sourceFilters.$select, mode);
+	if ($select !== void 0) result.$select = $select;
+	if ("$limit" in sourceFilters) result.$limit = sourceFilters.$limit;
+	else if ("$limit" in targetFilters) result.$limit = targetFilters.$limit;
+	if ("$skip" in sourceFilters) result.$skip = sourceFilters.$skip;
+	else if ("$skip" in targetFilters) result.$skip = targetFilters.$skip;
+	if ("$sort" in targetFilters || "$sort" in sourceFilters) result.$sort = {
+		...targetFilters.$sort,
+		...sourceFilters.$sort
+	};
+	return result;
+}
+//#endregion
 //#region src/utils/patch-batch/patch-batch.util.ts
 /**
 * Deterministic, key-order-independent serialization used to group items with
@@ -378,162 +555,6 @@ function patchBatch(items, options) {
 	});
 }
 //#endregion
-//#region src/utils/skip-result/skip-result.util.ts
-/**
-* Sets `context.result` to an appropriate empty value based on the hook method.
-* Returns an empty paginated object for paginated `find`, an empty array for multi
-* operations, or `null` for single-item operations. Does nothing if a result already exists.
-*
-* @example
-* ```ts
-* import { skipResult } from 'feathers-utils/utils'
-*
-* // In a before hook to skip the actual database call:
-* skipResult(context)
-* ```
-*
-* @see https://utils.feathersjs.com/utils/skip-result.html
-*/
-const skipResult = (context) => {
-	if (context.result) return context;
-	if (isMulti(context)) if (context.method === "find" && isPaginated(context)) context.result = {
-		total: 0,
-		skip: 0,
-		limit: 0,
-		data: []
-	};
-	else context.result = [];
-	else context.result = null;
-	return context;
-};
-//#endregion
-//#region src/utils/to-paginated/to-paginated.util.ts
-/**
-* Ensures a result is in Feathers paginated format (`{ total, limit, skip, data }`).
-* If the input is already paginated, it is returned as-is. If it is a plain array,
-* it is wrapped in a paginated object with `total` and `limit` set to the array length.
-*
-* @example
-* ```ts
-* import { toPaginated } from 'feathers-utils/utils'
-*
-* const paginated = toPaginated([{ id: 1 }, { id: 2 }])
-* // => { total: 2, limit: 2, skip: 0, data: [{ id: 1 }, { id: 2 }] }
-* ```
-*
-* @see https://utils.feathersjs.com/utils/to-paginated.html
-*/
-function toPaginated(result) {
-	if (Array.isArray(result)) return {
-		total: result.length,
-		limit: result.length,
-		skip: 0,
-		data: result
-	};
-	return result;
-}
-//#endregion
-//#region src/utils/transform-params/transform-params.util.ts
-/**
-* Safely applies a `transformParams` function to a params object.
-* If no function is provided, the original params are returned unchanged.
-* The function receives a shallow copy of params, so the original is not mutated.
-*
-* @example
-* ```ts
-* import { transformParams } from 'feathers-utils/utils'
-*
-* const params = transformParams(context.params, (p) => { delete p.provider; return p })
-* ```
-*
-* @see https://utils.feathersjs.com/utils/transform-params.html
-*/
-const transformParams = (params, fn) => {
-	if (!fn) return params;
-	return fn({ ...params }) ?? params;
-};
-//#endregion
-//#region src/utils/wait-for-service-event/wait-for-service-event.util.ts
-/**
-* Wait for a service event to fire and resolve with the emitted record. Useful
-* in tests to await the result of an asynchronous service event, a bit like
-* `promisify` for Feathers events.
-*
-* Curried: bind the `app` (and optional defaults) once, then call the returned
-* function per service/event. Resolves with a `[data, { event, context }]`
-* tuple: `data` is typed as the service's record type, and `event` is the union
-* of the requested events.
-*
-* Feathers emits events as `emit(event, record, context)` and fires one event
-* per record, so each resolution carries a single record and its `HookContext`.
-*
-* @example
-* ```ts
-* import { waitForServiceEvent } from 'feathers-utils/utils'
-*
-* const app = feathers()
-* const waitForEvent = waitForServiceEvent(app)
-*
-* // Wait for the next `users` record to be created.
-* const [user] = await waitForEvent('users', 'created')
-*
-* // Wait for a specific record, with a custom timeout and filter.
-* const [data, { event }] = await waitForEvent(
-*   'users',
-*   ['created', 'patched'],
-*   { filter: (user) => user.email === 'jane@example.com', timeout: 1000 },
-* )
-* ```
-*
-* @see https://utils.feathersjs.com/utils/wait-for-service-event.html
-*/
-function waitForServiceEvent(app, defaultOptions) {
-	return function waitForEvent(servicePath, eventOrEvents, options) {
-		const events = Array.isArray(eventOrEvents) ? eventOrEvents : [eventOrEvents];
-		const timeout = options?.timeout ?? defaultOptions?.timeout ?? 5e3;
-		const filter = options?.filter;
-		const signal = options?.signal ?? defaultOptions?.signal;
-		const service = app.service(servicePath);
-		return new Promise((resolve, reject) => {
-			let timer;
-			const listeners = events.map((event) => {
-				const listener = (data, context) => {
-					if (filter && !filter(data, context)) return;
-					cleanup();
-					resolve([data, {
-						event,
-						context
-					}]);
-				};
-				return [event, listener];
-			});
-			const abortError = () => signal?.reason ?? /* @__PURE__ */ new Error(`Aborted waiting for event "${events.join(", ")}" on service "${String(servicePath)}"`);
-			const onAbort = () => {
-				cleanup();
-				reject(abortError());
-			};
-			function cleanup() {
-				if (timer) {
-					clearTimeout(timer);
-					timer = void 0;
-				}
-				for (const [event, listener] of listeners) service.off(event, listener);
-				signal?.removeEventListener("abort", onAbort);
-			}
-			if (signal?.aborted) {
-				reject(abortError());
-				return;
-			}
-			if (timeout !== false) timer = setTimeout(() => {
-				cleanup();
-				reject(/* @__PURE__ */ new Error(`Timeout waiting for event "${events.join(", ")}" on service "${String(servicePath)}"`));
-			}, timeout);
-			signal?.addEventListener("abort", onAbort, { once: true });
-			for (const [event, listener] of listeners) service.on(event, listener);
-		});
-	};
-}
-//#endregion
 //#region src/utils/walk-query/walk-query.util.ts
 const _walkQueryUtil = (query, walker, state, options) => {
 	const stop = () => {
@@ -711,6 +732,162 @@ const queryDefaults = (query, defaults) => {
 	return addToQuery(source, toAdd);
 };
 //#endregion
+//#region src/utils/skip-result/skip-result.util.ts
+/**
+* Sets `context.result` to an appropriate empty value based on the hook method.
+* Returns an empty paginated object for paginated `find`, an empty array for multi
+* operations, or `null` for single-item operations. Does nothing if a result already exists.
+*
+* @example
+* ```ts
+* import { skipResult } from 'feathers-utils/utils'
+*
+* // In a before hook to skip the actual database call:
+* skipResult(context)
+* ```
+*
+* @see https://utils.feathersjs.com/utils/skip-result.html
+*/
+const skipResult = (context) => {
+	if (context.result) return context;
+	if (isMulti(context)) if (context.method === "find" && isPaginated(context)) context.result = {
+		total: 0,
+		skip: 0,
+		limit: 0,
+		data: []
+	};
+	else context.result = [];
+	else context.result = null;
+	return context;
+};
+//#endregion
+//#region src/utils/to-paginated/to-paginated.util.ts
+/**
+* Ensures a result is in Feathers paginated format (`{ total, limit, skip, data }`).
+* If the input is already paginated, it is returned as-is. If it is a plain array,
+* it is wrapped in a paginated object with `total` and `limit` set to the array length.
+*
+* @example
+* ```ts
+* import { toPaginated } from 'feathers-utils/utils'
+*
+* const paginated = toPaginated([{ id: 1 }, { id: 2 }])
+* // => { total: 2, limit: 2, skip: 0, data: [{ id: 1 }, { id: 2 }] }
+* ```
+*
+* @see https://utils.feathersjs.com/utils/to-paginated.html
+*/
+function toPaginated(result) {
+	if (Array.isArray(result)) return {
+		total: result.length,
+		limit: result.length,
+		skip: 0,
+		data: result
+	};
+	return result;
+}
+//#endregion
+//#region src/utils/transform-params/transform-params.util.ts
+/**
+* Safely applies a `transformParams` function to a params object.
+* If no function is provided, the original params are returned unchanged.
+* The function receives a shallow copy of params, so the original is not mutated.
+*
+* @example
+* ```ts
+* import { transformParams } from 'feathers-utils/utils'
+*
+* const params = transformParams(context.params, (p) => { delete p.provider; return p })
+* ```
+*
+* @see https://utils.feathersjs.com/utils/transform-params.html
+*/
+const transformParams = (params, fn) => {
+	if (!fn) return params;
+	return fn({ ...params }) ?? params;
+};
+//#endregion
+//#region src/utils/wait-for-service-event/wait-for-service-event.util.ts
+/**
+* Wait for a service event to fire and resolve with the emitted record. Useful
+* in tests to await the result of an asynchronous service event, a bit like
+* `promisify` for Feathers events.
+*
+* Curried: bind the `app` (and optional defaults) once, then call the returned
+* function per service/event. Resolves with a `[data, { event, context }]`
+* tuple: `data` is typed as the service's record type, and `event` is the union
+* of the requested events.
+*
+* Feathers emits events as `emit(event, record, context)` and fires one event
+* per record, so each resolution carries a single record and its `HookContext`.
+*
+* @example
+* ```ts
+* import { waitForServiceEvent } from 'feathers-utils/utils'
+*
+* const app = feathers()
+* const waitForEvent = waitForServiceEvent(app)
+*
+* // Wait for the next `users` record to be created.
+* const [user] = await waitForEvent('users', 'created')
+*
+* // Wait for a specific record, with a custom timeout and filter.
+* const [data, { event }] = await waitForEvent(
+*   'users',
+*   ['created', 'patched'],
+*   { filter: (user) => user.email === 'jane@example.com', timeout: 1000 },
+* )
+* ```
+*
+* @see https://utils.feathersjs.com/utils/wait-for-service-event.html
+*/
+function waitForServiceEvent(app, defaultOptions) {
+	return function waitForEvent(servicePath, eventOrEvents, options) {
+		const events = Array.isArray(eventOrEvents) ? eventOrEvents : [eventOrEvents];
+		const timeout = options?.timeout ?? defaultOptions?.timeout ?? 5e3;
+		const filter = options?.filter;
+		const signal = options?.signal ?? defaultOptions?.signal;
+		const service = app.service(servicePath);
+		return new Promise((resolve, reject) => {
+			let timer;
+			const listeners = events.map((event) => {
+				const listener = (data, context) => {
+					if (filter && !filter(data, context)) return;
+					cleanup();
+					resolve([data, {
+						event,
+						context
+					}]);
+				};
+				return [event, listener];
+			});
+			const abortError = () => signal?.reason ?? /* @__PURE__ */ new Error(`Aborted waiting for event "${events.join(", ")}" on service "${String(servicePath)}"`);
+			const onAbort = () => {
+				cleanup();
+				reject(abortError());
+			};
+			function cleanup() {
+				if (timer) {
+					clearTimeout(timer);
+					timer = void 0;
+				}
+				for (const [event, listener] of listeners) service.off(event, listener);
+				signal?.removeEventListener("abort", onAbort);
+			}
+			if (signal?.aborted) {
+				reject(abortError());
+				return;
+			}
+			if (timeout !== false) timer = setTimeout(() => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error(`Timeout waiting for event "${events.join(", ")}" on service "${String(servicePath)}"`));
+			}, timeout);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			for (const [event, listener] of listeners) service.on(event, listener);
+		});
+	};
+}
+//#endregion
 //#region src/utils/zip-data-result/zip-data-result.util.ts
 /**
 * Pairs each item in `context.data` with its corresponding item in `context.result` by index.
@@ -749,6 +926,6 @@ function zipDataResult(context, options) {
 	return result;
 }
 //#endregion
-export { addSkip as _, waitForServiceEvent as a, skipResult as c, getExposedMethods as d, defineHooks as f, chunkFind as g, addToQuery as h, walkQuery as i, patchBatch as l, checkContext as m, queryDefaults as n, transformParams as o, contextToJson as p, queryHasProperty as r, toPaginated as s, zipDataResult as t, iterateFind as u, sortQueryProperties as v };
+export { addToQuery as _, skipResult as a, walkQuery as c, iterateFind as d, getExposedMethods as f, checkContext as g, chunkFind as h, toPaginated as i, patchBatch as l, contextToJson as m, waitForServiceEvent as n, queryDefaults as o, defineHooks as p, transformParams as r, queryHasProperty as s, zipDataResult as t, mergeQuery as u, addSkip as v, sortQueryProperties as y };
 
-//# sourceMappingURL=utils-BAIcSl7u.mjs.map
+//# sourceMappingURL=utils-DByCpAsf.mjs.map