@sia-ui/utils 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivan Mbella
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,39 @@
+# @sia-ui/utils
+
+Les helpers qu'on réécrit d'un projet à l'autre, sans dépendance.
+
+```bash
+pnpm add @sia-ui/utils
+```
+
+```ts
+import { formatCurrency } from "@sia-ui/utils/currency";
+import { formatTimeAgo } from "@sia-ui/utils/date";
+import { cn } from "@sia-ui/utils/classname";
+
+formatCurrency(1500000, { currency: "XAF" });  // "1 500 000 FCFA"
+formatTimeAgo(commande.createdAt);              // "il y a 10 minutes"
+```
+
+Cinq modules — `classname`, `currency`, `date`, `events`, `number`, `string` —
+importables séparément pour rester léger. Tout repose sur `Intl`, donc rien à
+embarquer : `XOF` et `XAF` sont formatés correctement.
+
+## Place dans SIA UI
+
+```
+@sia-ui/tokens      valeurs : couleurs, espacements, mouvement, vocabulaire
+@sia-ui/utils       fonctions sans dépendance
+@sia-ui/api         client HTTP — indépendant de l'interface
+@sia-ui/headless    comportement, avec React, sans plateforme
+@sia-ui/react       primitives de runtime DOM
+@sia-ui/react-web   composants DOM
+@sia-ui/react-native  composants natifs, à venir
+```
+
+Une chose s'écrit au niveau le plus bas où elle a du sens, et une seule fois.
+Voir [la documentation](https://github.com/BeatJo/sia-ui/tree/main/docs).
+
+## Licence
+
+MIT

package/dist/async.cjs

@@ -0,0 +1,134 @@
+'use strict';
+
+// src/async.ts
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new Error("Annul\xE9"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new Error("Annul\xE9"));
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function debounce(fn, wait = 250, options = {}) {
+  const { leading = false, trailing = true } = options;
+  let timer;
+  let lastArgs;
+  const run = () => {
+    timer = void 0;
+    if (trailing && lastArgs) {
+      const args = lastArgs;
+      lastArgs = void 0;
+      fn(...args);
+    }
+  };
+  const debounced = ((...args) => {
+    lastArgs = args;
+    if (timer === void 0 && leading) {
+      lastArgs = void 0;
+      fn(...args);
+    }
+    if (timer !== void 0) clearTimeout(timer);
+    timer = setTimeout(run, wait);
+  });
+  debounced.cancel = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = void 0;
+    lastArgs = void 0;
+  };
+  debounced.flush = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    run();
+  };
+  debounced.pending = () => timer !== void 0;
+  return debounced;
+}
+function throttle(fn, wait = 100) {
+  let last = 0;
+  let timer;
+  let lastArgs;
+  const invoke = (args) => {
+    last = Date.now();
+    lastArgs = void 0;
+    fn(...args);
+  };
+  const throttled = ((...args) => {
+    const elapsed = Date.now() - last;
+    lastArgs = args;
+    if (elapsed >= wait) {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      invoke(args);
+      return;
+    }
+    if (timer === void 0) {
+      timer = setTimeout(() => {
+        timer = void 0;
+        if (lastArgs) invoke(lastArgs);
+      }, wait - elapsed);
+    }
+  });
+  throttled.cancel = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = void 0;
+    lastArgs = void 0;
+  };
+  throttled.flush = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = void 0;
+    if (lastArgs) invoke(lastArgs);
+  };
+  throttled.pending = () => timer !== void 0;
+  return throttled;
+}
+function createRetry(options = {}) {
+  const {
+    retries = 2,
+    delay = 300,
+    maxDelay = 8e3,
+    shouldRetry = () => true,
+    onRetry,
+    signal
+  } = options;
+  return async function run(task) {
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+      try {
+        return await task(attempt);
+      } catch (error) {
+        lastError = error;
+        if (attempt === retries || !shouldRetry(error, attempt)) throw error;
+        onRetry?.(error, attempt);
+        const base = Math.min(delay * 2 ** attempt, maxDelay);
+        await sleep(base + Math.random() * 0.1 * base, signal);
+      }
+    }
+    throw lastError;
+  };
+}
+function toAsyncState(input) {
+  const { data, error, isLoading = false } = input;
+  if (error !== void 0 && error !== null) return { status: "error", error };
+  if (isLoading) return { status: "loading" };
+  if (data === void 0 || data === null) return { status: "idle" };
+  if (Array.isArray(data) && data.length === 0) {
+    return { status: "empty", data };
+  }
+  return { status: "success", data };
+}
+
+exports.createRetry = createRetry;
+exports.debounce = debounce;
+exports.sleep = sleep;
+exports.throttle = throttle;
+exports.toAsyncState = toAsyncState;

package/dist/async.d.cts

@@ -0,0 +1,81 @@
+/**
+ * Le temps et les promesses.
+ *
+ * `AsyncStatus` et `AsyncState` vivent ici plutôt que dans un paquet
+ * d'interface : un état de chargement n'a rien à voir avec le rendu, et le
+ * même trio `data / error / isLoading` sort de TanStack Query, de SWR ou
+ * d'un `useState` écrit à la main.
+ */
+type AsyncStatus = "idle" | "loading" | "success" | "empty" | "error";
+interface AsyncState<T> {
+    status: AsyncStatus;
+    data?: T;
+    error?: unknown;
+}
+/** Attend, en respectant une annulation. */
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+interface Debounced<A extends unknown[]> {
+    (...args: A): void;
+    /** Abandonne l'appel en attente. */
+    cancel: () => void;
+    /** Exécute tout de suite l'appel en attente, s'il y en a un. */
+    flush: () => void;
+    pending: () => boolean;
+}
+interface DebounceOptions {
+    /** Exécute au premier appel plutôt qu'au dernier. */
+    leading?: boolean;
+    /** Exécute aussi à la fin. Avec `leading`, les deux sont possibles. */
+    trailing?: boolean;
+}
+/**
+ * Attend que ça se calme avant d'agir.
+ *
+ * Pour une recherche pendant la frappe : c'est le dernier appel qui compte,
+ * pas les douze précédents. `cancel` est indispensable au démontage — sans
+ * lui, la requête part alors que le composant n'existe plus.
+ */
+declare function debounce<A extends unknown[]>(fn: (...args: A) => void, wait?: number, options?: DebounceOptions): Debounced<A>;
+/**
+ * Limite la cadence, sans rien perdre du dernier appel.
+ *
+ * Pour un défilement ou un redimensionnement : on veut une réaction
+ * régulière, pas une par image. Contrairement au `debounce`, le premier
+ * appel passe tout de suite.
+ */
+declare function throttle<A extends unknown[]>(fn: (...args: A) => void, wait?: number): Debounced<A>;
+interface RetryOptions {
+    /** Nombre de tentatives supplémentaires après la première. */
+    retries?: number;
+    /** Délai de base, doublé à chaque tentative. */
+    delay?: number;
+    /** Plafond du délai, pour que l'attente reste supportable. */
+    maxDelay?: number;
+    /** Décide si l'erreur mérite une nouvelle tentative. */
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+    onRetry?: (error: unknown, attempt: number) => void;
+    signal?: AbortSignal;
+}
+/**
+ * Construit une fonction qui réessaie.
+ *
+ * Le délai double à chaque tentative, avec une part aléatoire : dix clients
+ * qui échouent en même temps ne doivent pas revenir tous ensemble, sinon le
+ * serveur qui se relève retombe aussitôt.
+ */
+declare function createRetry(options?: RetryOptions): <T>(task: (attempt: number) => Promise<T>) => Promise<T>;
+interface ToAsyncStateInput<T> {
+    data?: T | null | undefined;
+    error?: unknown;
+    isLoading?: boolean;
+}
+/**
+ * Traduit le trio `data / error / isLoading` en un état unique.
+ *
+ * C'est ce que rendent TanStack Query, SWR et RTK Query, et c'est ce que le
+ * composant `AsyncState` attend. Le cas qui justifie la fonction est `empty` :
+ * une liste chargée mais vide n'est pas un succès qu'on affiche tel quel.
+ */
+declare function toAsyncState<T>(input: ToAsyncStateInput<T>): AsyncState<T>;
+
+export { type AsyncState, type AsyncStatus, type DebounceOptions, type Debounced, type RetryOptions, type ToAsyncStateInput, createRetry, debounce, sleep, throttle, toAsyncState };

package/dist/async.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Le temps et les promesses.
+ *
+ * `AsyncStatus` et `AsyncState` vivent ici plutôt que dans un paquet
+ * d'interface : un état de chargement n'a rien à voir avec le rendu, et le
+ * même trio `data / error / isLoading` sort de TanStack Query, de SWR ou
+ * d'un `useState` écrit à la main.
+ */
+type AsyncStatus = "idle" | "loading" | "success" | "empty" | "error";
+interface AsyncState<T> {
+    status: AsyncStatus;
+    data?: T;
+    error?: unknown;
+}
+/** Attend, en respectant une annulation. */
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+interface Debounced<A extends unknown[]> {
+    (...args: A): void;
+    /** Abandonne l'appel en attente. */
+    cancel: () => void;
+    /** Exécute tout de suite l'appel en attente, s'il y en a un. */
+    flush: () => void;
+    pending: () => boolean;
+}
+interface DebounceOptions {
+    /** Exécute au premier appel plutôt qu'au dernier. */
+    leading?: boolean;
+    /** Exécute aussi à la fin. Avec `leading`, les deux sont possibles. */
+    trailing?: boolean;
+}
+/**
+ * Attend que ça se calme avant d'agir.
+ *
+ * Pour une recherche pendant la frappe : c'est le dernier appel qui compte,
+ * pas les douze précédents. `cancel` est indispensable au démontage — sans
+ * lui, la requête part alors que le composant n'existe plus.
+ */
+declare function debounce<A extends unknown[]>(fn: (...args: A) => void, wait?: number, options?: DebounceOptions): Debounced<A>;
+/**
+ * Limite la cadence, sans rien perdre du dernier appel.
+ *
+ * Pour un défilement ou un redimensionnement : on veut une réaction
+ * régulière, pas une par image. Contrairement au `debounce`, le premier
+ * appel passe tout de suite.
+ */
+declare function throttle<A extends unknown[]>(fn: (...args: A) => void, wait?: number): Debounced<A>;
+interface RetryOptions {
+    /** Nombre de tentatives supplémentaires après la première. */
+    retries?: number;
+    /** Délai de base, doublé à chaque tentative. */
+    delay?: number;
+    /** Plafond du délai, pour que l'attente reste supportable. */
+    maxDelay?: number;
+    /** Décide si l'erreur mérite une nouvelle tentative. */
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+    onRetry?: (error: unknown, attempt: number) => void;
+    signal?: AbortSignal;
+}
+/**
+ * Construit une fonction qui réessaie.
+ *
+ * Le délai double à chaque tentative, avec une part aléatoire : dix clients
+ * qui échouent en même temps ne doivent pas revenir tous ensemble, sinon le
+ * serveur qui se relève retombe aussitôt.
+ */
+declare function createRetry(options?: RetryOptions): <T>(task: (attempt: number) => Promise<T>) => Promise<T>;
+interface ToAsyncStateInput<T> {
+    data?: T | null | undefined;
+    error?: unknown;
+    isLoading?: boolean;
+}
+/**
+ * Traduit le trio `data / error / isLoading` en un état unique.
+ *
+ * C'est ce que rendent TanStack Query, SWR et RTK Query, et c'est ce que le
+ * composant `AsyncState` attend. Le cas qui justifie la fonction est `empty` :
+ * une liste chargée mais vide n'est pas un succès qu'on affiche tel quel.
+ */
+declare function toAsyncState<T>(input: ToAsyncStateInput<T>): AsyncState<T>;
+
+export { type AsyncState, type AsyncStatus, type DebounceOptions, type Debounced, type RetryOptions, type ToAsyncStateInput, createRetry, debounce, sleep, throttle, toAsyncState };

package/dist/async.js

@@ -0,0 +1 @@
+export { createRetry, debounce, sleep, throttle, toAsyncState } from './chunk-DKWI2AZG.js';

package/dist/chunk-63IWZEOC.js

@@ -0,0 +1,51 @@
+// src/number.ts
+function formatter(locale, options) {
+  return new Intl.NumberFormat(locale, options);
+}
+function formatNumber(value, options = {}) {
+  const { locale = "fr-FR", ...formatOptions } = options;
+  return formatter(locale, { maximumFractionDigits: 2, ...formatOptions }).format(value);
+}
+function formatPercent(value, options = {}) {
+  const { locale = "fr-FR", ...formatOptions } = options;
+  return formatter(locale, {
+    style: "percent",
+    maximumFractionDigits: 2,
+    ...formatOptions
+  }).format(value);
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function round(value, digits = 0) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+function toNumber(value, fallback = 0) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return fallback;
+}
+function parseDecimal(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error("The provided numeric value is invalid.");
+  }
+  return parsed;
+}
+function roundCurrency(value) {
+  return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+function formatRate(value) {
+  return value.toFixed(4);
+}
+function safeDivide(a, b, fallback = 0) {
+  if (b === 0) return fallback;
+  const result = a / b;
+  return Number.isFinite(result) ? result : fallback;
+}
+
+export { clamp, formatNumber, formatPercent, formatRate, parseDecimal, round, roundCurrency, safeDivide, toNumber };

package/dist/chunk-6P4YWHCJ.js

@@ -0,0 +1,47 @@
+// src/locale.ts
+var DEFAULT_LOCALE = "fr-FR";
+function resolveLocale(preferred) {
+  if (preferred) return preferred;
+  if (typeof navigator !== "undefined" && navigator.language) {
+    return navigator.language;
+  }
+  return DEFAULT_LOCALE;
+}
+function languageOf(locale = DEFAULT_LOCALE) {
+  return locale.split("-")[0] ?? locale;
+}
+function regionOf(locale = DEFAULT_LOCALE) {
+  return locale.split("-")[1];
+}
+var collators = /* @__PURE__ */ new Map();
+function collator(locale = DEFAULT_LOCALE) {
+  let found = collators.get(locale);
+  if (!found) {
+    found = new Intl.Collator(locale, { sensitivity: "base", numeric: true });
+    collators.set(locale, found);
+  }
+  return found;
+}
+function compareStrings(a, b, locale = DEFAULT_LOCALE) {
+  return collator(locale).compare(a, b);
+}
+function looseIncludes(text, needle, locale = DEFAULT_LOCALE) {
+  if (!needle) return true;
+  const strip = (value) => value.toLocaleLowerCase(locale).normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+  return strip(text).includes(strip(needle));
+}
+function formatList(items, options = {}) {
+  const { locale = DEFAULT_LOCALE, type = "conjunction" } = options;
+  if (items.length === 0) return "";
+  return new Intl.ListFormat(locale, { style: "long", type }).format(items);
+}
+function plural(count, singular, pluralForm) {
+  return Math.abs(count) < 2 ? singular : pluralForm ?? `${singular}s`;
+}
+function countLabel(count, singular, options = {}) {
+  const { pluralForm, zero, locale = DEFAULT_LOCALE } = options;
+  if (count === 0 && zero) return zero;
+  return `${count.toLocaleString(locale)} ${plural(count, singular, pluralForm)}`;
+}
+
+export { DEFAULT_LOCALE, collator, compareStrings, countLabel, formatList, languageOf, looseIncludes, plural, regionOf, resolveLocale };

package/dist/chunk-BMNZVRFN.js

@@ -0,0 +1,25 @@
+// src/classname.ts
+function append(tokens, value) {
+  if (!value) return;
+  if (typeof value === "string" || typeof value === "number") {
+    tokens.push(String(value));
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) append(tokens, item);
+    return;
+  }
+  for (const [key, enabled] of Object.entries(value)) {
+    if (enabled) tokens.push(key);
+  }
+}
+function cn(...inputs) {
+  const tokens = [];
+  for (const input of inputs) append(tokens, input);
+  return tokens.join(" ");
+}
+function toneClass(block, tone) {
+  return `${block}--${tone}`;
+}
+
+export { cn, toneClass };

package/dist/chunk-DKWI2AZG.js

@@ -0,0 +1,128 @@
+// src/async.ts
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new Error("Annul\xE9"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new Error("Annul\xE9"));
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function debounce(fn, wait = 250, options = {}) {
+  const { leading = false, trailing = true } = options;
+  let timer;
+  let lastArgs;
+  const run = () => {
+    timer = void 0;
+    if (trailing && lastArgs) {
+      const args = lastArgs;
+      lastArgs = void 0;
+      fn(...args);
+    }
+  };
+  const debounced = ((...args) => {
+    lastArgs = args;
+    if (timer === void 0 && leading) {
+      lastArgs = void 0;
+      fn(...args);
+    }
+    if (timer !== void 0) clearTimeout(timer);
+    timer = setTimeout(run, wait);
+  });
+  debounced.cancel = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = void 0;
+    lastArgs = void 0;
+  };
+  debounced.flush = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    run();
+  };
+  debounced.pending = () => timer !== void 0;
+  return debounced;
+}
+function throttle(fn, wait = 100) {
+  let last = 0;
+  let timer;
+  let lastArgs;
+  const invoke = (args) => {
+    last = Date.now();
+    lastArgs = void 0;
+    fn(...args);
+  };
+  const throttled = ((...args) => {
+    const elapsed = Date.now() - last;
+    lastArgs = args;
+    if (elapsed >= wait) {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      invoke(args);
+      return;
+    }
+    if (timer === void 0) {
+      timer = setTimeout(() => {
+        timer = void 0;
+        if (lastArgs) invoke(lastArgs);
+      }, wait - elapsed);
+    }
+  });
+  throttled.cancel = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = void 0;
+    lastArgs = void 0;
+  };
+  throttled.flush = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = void 0;
+    if (lastArgs) invoke(lastArgs);
+  };
+  throttled.pending = () => timer !== void 0;
+  return throttled;
+}
+function createRetry(options = {}) {
+  const {
+    retries = 2,
+    delay = 300,
+    maxDelay = 8e3,
+    shouldRetry = () => true,
+    onRetry,
+    signal
+  } = options;
+  return async function run(task) {
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+      try {
+        return await task(attempt);
+      } catch (error) {
+        lastError = error;
+        if (attempt === retries || !shouldRetry(error, attempt)) throw error;
+        onRetry?.(error, attempt);
+        const base = Math.min(delay * 2 ** attempt, maxDelay);
+        await sleep(base + Math.random() * 0.1 * base, signal);
+      }
+    }
+    throw lastError;
+  };
+}
+function toAsyncState(input) {
+  const { data, error, isLoading = false } = input;
+  if (error !== void 0 && error !== null) return { status: "error", error };
+  if (isLoading) return { status: "loading" };
+  if (data === void 0 || data === null) return { status: "idle" };
+  if (Array.isArray(data) && data.length === 0) {
+    return { status: "empty", data };
+  }
+  return { status: "success", data };
+}
+
+export { createRetry, debounce, sleep, throttle, toAsyncState };

package/dist/chunk-DY6WSWXH.js

@@ -0,0 +1,60 @@
+// src/query.ts
+function serialize(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function toQueryString(params, options = {}) {
+  if (!params) return "";
+  const { prefix = true, skipEmpty = false } = options;
+  const entries = Object.entries(params).filter(([, value]) => value !== void 0 && value !== null).flatMap(([key, value]) => {
+    const values = Array.isArray(value) ? value : [value];
+    return values.filter((item) => item !== void 0 && item !== null).map((item) => serialize(item)).filter((item) => !skipEmpty || item !== "").map(
+      (item) => `${encodeURIComponent(key)}=${encodeURIComponent(item)}`
+    );
+  });
+  if (entries.length === 0) return "";
+  return `${prefix ? "?" : ""}${entries.join("&")}`;
+}
+function fromQueryString(search) {
+  const params = new URLSearchParams(
+    search.startsWith("?") ? search.slice(1) : search
+  );
+  const out = {};
+  for (const [key, value] of params) {
+    const existing = out[key];
+    if (existing === void 0) out[key] = value;
+    else if (Array.isArray(existing)) existing.push(value);
+    else out[key] = [existing, value];
+  }
+  return out;
+}
+function removeEmptyParams(params) {
+  const out = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value === null || value === void 0) continue;
+    if (value === "") continue;
+    if (Array.isArray(value) && value.length === 0) continue;
+    out[key] = value;
+  }
+  return out;
+}
+function mergeSearchParams(base, patch, options = {}) {
+  const params = new URLSearchParams(
+    base.startsWith("?") ? base.slice(1) : base
+  );
+  for (const [key, value] of Object.entries(patch)) {
+    params.delete(key);
+    if (value === null || value === void 0) continue;
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      if (item === null || item === void 0) continue;
+      params.append(key, serialize(item));
+    }
+  }
+  const result = params.toString();
+  if (!result) return "";
+  return `${options.prefix === false ? "" : "?"}${result}`;
+}
+
+export { fromQueryString, mergeSearchParams, removeEmptyParams, toQueryString };