@cedvict/http-guardian 0.0.1-next.5 → 0.0.1-next.7

package/dist/index.cjs

@@ -0,0 +1,1413 @@
+'use strict';
+
+// src/internal/compose.ts
+function composeGuards(guards, terminal) {
+  if (!guards.length) return terminal;
+  return (ctx) => dispatch(0, ctx);
+  function dispatch(i, c) {
+    const guard = guards[i];
+    if (!guard) return terminal(c);
+    return Promise.resolve(
+      guard(c, (nextCtx) => dispatch(i + 1, nextCtx ?? c))
+    );
+  }
+}
+
+// src/internal/url.ts
+function joinUrl(baseUrl, path) {
+  if (!baseUrl) return path;
+  if (path.startsWith("http://") || path.startsWith("https://")) return path;
+  const b = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${b}${p}`;
+}
+function withQuery(url, query) {
+  if (!query) return url;
+  const u = new URL(url);
+  for (const [k, v] of Object.entries(query)) {
+    if (v === void 0 || v === null) continue;
+    u.searchParams.set(k, String(v));
+  }
+  return u.toString();
+}
+
+// src/internal/authGuard.ts
+function sanitizeHeaderValue(v) {
+  if (/[\r\n]/.test(v)) return null;
+  return v;
+}
+function base64Encode(input) {
+  if (typeof globalThis.btoa === "function") return globalThis.btoa(input);
+  const B = globalThis.Buffer;
+  if (typeof B?.from === "function") return B.from(input, "utf8").toString("base64");
+  throw new Error("No base64 encoder available in this runtime");
+}
+function isUnsafeMethod(m) {
+  const u = m.toUpperCase();
+  return u !== "GET" && u !== "HEAD" && u !== "OPTIONS";
+}
+function sameOrigin(url, baseOrigin) {
+  if (!baseOrigin) return true;
+  try {
+    return new URL(url).origin === baseOrigin;
+  } catch {
+    return true;
+  }
+}
+function isAllowedOrigin(url, baseOrigin, allowed) {
+  if (!allowed) return sameOrigin(url, baseOrigin);
+  if (typeof allowed === "function") return !!allowed(url);
+  try {
+    const origin = new URL(url).origin;
+    return allowed.includes(origin);
+  } catch {
+    return true;
+  }
+}
+function authGuard(auth) {
+  return async (ctx, next) => {
+    if (ctx.noAuth) return next(ctx);
+    if (auth.mode === "none") return next(ctx);
+    if (auth.mode === "bearer") {
+      const token = await auth.getToken();
+      if (token) {
+        if (!isAllowedOrigin(ctx.url, ctx.baseOrigin, auth.allowedOrigins)) {
+          return next(ctx);
+        }
+        const headerName = auth.headerName ?? "Authorization";
+        const prefix = auth.prefix ?? "Bearer";
+        const safe = sanitizeHeaderValue(`${prefix} ${token}`);
+        if (safe) ctx.headers.set(headerName, safe);
+      }
+      return next(ctx);
+    }
+    if (auth.mode === "basic") {
+      const cred = await auth.getCredentials();
+      if (cred) {
+        if (!isAllowedOrigin(ctx.url, ctx.baseOrigin, auth.allowedOrigins)) {
+          return next(ctx);
+        }
+        const headerName = auth.headerName ?? "Authorization";
+        const prefix = auth.prefix ?? "Basic";
+        const raw = typeof cred === "string" ? cred : `${cred.username}:${cred.password}`;
+        const safe = sanitizeHeaderValue(`${prefix} ${base64Encode(raw)}`);
+        if (safe) ctx.headers.set(headerName, safe);
+      }
+      return next(ctx);
+    }
+    if (auth.mode === "apiKey") {
+      const key = await auth.getKey();
+      if (key) {
+        if (!isAllowedOrigin(ctx.url, ctx.baseOrigin, auth.allowedOrigins)) {
+          return next(ctx);
+        }
+        const headerName = auth.headerName ?? "X-API-Key";
+        const prefix = auth.prefix ?? "";
+        const value = prefix ? `${prefix} ${key}` : key;
+        const safe = sanitizeHeaderValue(value);
+        if (safe) ctx.headers.set(headerName, safe);
+      }
+      return next(ctx);
+    }
+    ctx.credentials = auth.credentials ?? "include";
+    if (auth.csrf && isUnsafeMethod(ctx.method)) {
+      const csrf = await auth.csrf.getToken();
+      if (csrf) ctx.headers.set(auth.csrf.headerName, csrf);
+    }
+    return next(ctx);
+  };
+}
+
+// src/internal/headersPolyfill.ts
+function norm(name) {
+  return String(name).toLowerCase();
+}
+var HeadersPolyfill = class {
+  map = /* @__PURE__ */ new Map();
+  constructor(init) {
+    if (!init) return;
+    if (typeof init.forEach === "function" && typeof init.get === "function") {
+      init.forEach((v, k) => this.set(k, v));
+      return;
+    }
+    if (Symbol.iterator in Object(init)) {
+      for (const [k, v] of init) this.append(k, v);
+      return;
+    }
+    for (const [k, v] of Object.entries(init)) {
+      this.set(k, String(v));
+    }
+  }
+  get(name) {
+    const hit = this.map.get(norm(name));
+    return hit ? hit.value : null;
+  }
+  has(name) {
+    return this.map.has(norm(name));
+  }
+  set(name, value) {
+    this.map.set(norm(name), { name, value: String(value) });
+  }
+  append(name, value) {
+    const key = norm(name);
+    const prev = this.map.get(key);
+    if (!prev) {
+      this.map.set(key, { name, value: String(value) });
+      return;
+    }
+    this.map.set(key, { name: prev.name, value: `${prev.value}, ${String(value)}` });
+  }
+  delete(name) {
+    this.map.delete(norm(name));
+  }
+  forEach(cb) {
+    for (const { name, value } of this.map.values()) cb(value, name);
+  }
+  entries() {
+    const it = this.map.values();
+    return {
+      [Symbol.iterator]() {
+        return this;
+      },
+      next() {
+        const n = it.next();
+        if (n.done) return { done: true, value: void 0 };
+        return { done: false, value: [n.value.name, n.value.value] };
+      }
+    };
+  }
+  /** Convert to HeadersInit that any fetch can consume. */
+  toObject() {
+    const out = {};
+    for (const { name, value } of this.map.values()) out[name] = value;
+    return out;
+  }
+};
+function createHeaders(init) {
+  if (typeof globalThis.Headers === "function") {
+    return new globalThis.Headers(init);
+  }
+  return new HeadersPolyfill(init);
+}
+function toFetchHeaders(headers) {
+  if (typeof globalThis.Headers === "function" && headers instanceof globalThis.Headers) {
+    return headers;
+  }
+  return headers.toObject();
+}
+
+// src/internal/stableStringify.ts
+function stableStringify(value) {
+  return JSON.stringify(sortValue(value));
+}
+function sortValue(v) {
+  if (v === null || typeof v !== "object") return v;
+  if (Array.isArray(v)) return v.map(sortValue);
+  const proto = Object.getPrototypeOf(v);
+  if (proto !== Object.prototype && proto !== null) return v;
+  const out = {};
+  for (const key of Object.keys(v).sort()) out[key] = sortValue(v[key]);
+  return out;
+}
+
+// src/cache/key.ts
+function makeCacheKey(parts) {
+  if (parts.keyOverride) return parts.keyOverride;
+  const headerObj = {};
+  if (parts.headers) {
+    const accept = parts.headers.get("accept");
+    const contentType = parts.headers.get("content-type");
+    if (accept) headerObj["accept"] = accept;
+    if (contentType) headerObj["content-type"] = contentType;
+  }
+  return stableStringify({
+    m: parts.method,
+    u: parts.url,
+    h: headerObj,
+    b: parts.body ?? null,
+    i: parts.idempotencyKey ?? null
+  });
+}
+
+// src/cache/inFlight.ts
+var InFlight = class {
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.map.get(key);
+  }
+  set(key, p) {
+    this.map.set(key, p);
+    p.finally(() => {
+      if (this.map.get(key) === p) this.map.delete(key);
+    }).catch(() => {
+    });
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+
+// src/notify/defaults.ts
+var consoleNotifier = {
+  notify: (e) => {
+    console[e.level === "error" ? "error" : "warn"](`[${e.type}] ${e.title}: ${e.message}`, e);
+  }
+};
+var alertNotifier = {
+  notify: (e) => {
+    if (typeof window !== "undefined" && typeof window.alert === "function") window.alert(`${e.title}
+
+${e.message}`);
+  }
+};
+function tailwindAlertRenderer(event) {
+  const base = "rounded-lg border p-4 shadow-sm";
+  const color = event.level === "warning" ? "border-amber-200 bg-amber-50 text-amber-900" : "border-red-200 bg-red-50 text-red-900";
+  const title = escapeHtml(event.title);
+  const msg = escapeHtml(event.message);
+  return `<div class="${base} ${color}"><div class="font-semibold">${title}</div><div class="mt-1 text-sm">${msg}</div></div>`;
+}
+function escapeHtml(s) {
+  return s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+}
+
+// src/client/errors.ts
+var NetworkError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+  }
+  name = "NetworkError";
+};
+var TimeoutError = class extends Error {
+  name = "TimeoutError";
+  constructor(message = "Request timed out") {
+    super(message);
+  }
+};
+var RedirectError = class extends Error {
+  constructor(message, fromUrl, toUrl) {
+    super(message);
+    this.fromUrl = fromUrl;
+    this.toUrl = toUrl;
+  }
+  name = "RedirectError";
+};
+var ParseError = class extends Error {
+  constructor(message, raw, cause) {
+    super(message);
+    this.raw = raw;
+    this.cause = cause;
+  }
+  name = "ParseError";
+};
+var ILLEGAL_INVOCATION_HINT = `Detected a browser fetch invocation error ("Illegal invocation"). This usually happens when passing a detached reference to window.fetch. Fix by configuring the client with fetch: (input, init) => window.fetch(input, init) or fetch: window.fetch.bind(window).`;
+
+// src/client/httpClient.ts
+function isIllegalInvocation(err) {
+  const msg = String(err?.message ?? err);
+  return /Illegal invocation/i.test(msg);
+}
+function normalizeFetch(f) {
+  const bound = f.bind ? f.bind(globalThis) : f;
+  return ((input, init) => bound(input, init));
+}
+function getDefaultFetch() {
+  if (typeof globalThis.fetch === "function") return globalThis.fetch;
+  throw new Error(
+    "No global fetch detected. Provide a fetch implementation via createHttpClient({ fetch }) or run in an environment that supports fetch (Node >= 18 / modern browsers)."
+  );
+}
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function createHttpClient(options) {
+  const draft = { ...options };
+  if (draft.plugins?.length) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of draft.plugins) {
+      if (!p || !p.name || typeof p.apply !== "function") continue;
+      if (seen.has(p.name)) continue;
+      seen.add(p.name);
+      p.apply(draft);
+    }
+  }
+  const resolvedFetch = (() => {
+    if (draft.fetch) return normalizeFetch(draft.fetch);
+    let lastRef = null;
+    let lastBound = null;
+    return ((input, init) => {
+      const cur = getDefaultFetch();
+      if (cur !== lastRef || !lastBound) {
+        lastRef = cur;
+        lastBound = normalizeFetch(cur);
+      }
+      return lastBound(input, init);
+    });
+  })();
+  const cache = draft.cache;
+  const inFlight = new InFlight();
+  const defaultNotifier = draft.notifier ?? consoleNotifier;
+  const shouldNotify = draft.defaults?.shouldNotify ?? ((r) => !r.ok);
+  const baseGuards = [authGuard(draft.auth), ...draft.guards ?? []];
+  async function terminal(ctx) {
+    const controller = ctx.timeoutMs ? new AbortController() : void 0;
+    const timeout = ctx.timeoutMs ? setTimeout(() => controller?.abort(new TimeoutError()), ctx.timeoutMs) : void 0;
+    try {
+      const init = {
+        method: ctx.method,
+        headers: toFetchHeaders(ctx.headers),
+        ...ctx.body !== void 0 ? { body: ctx.body } : {},
+        ...ctx.signal ? { signal: controller ? anySignal([ctx.signal, controller.signal]) : ctx.signal } : controller ? { signal: controller.signal } : {},
+        ...ctx.credentials !== void 0 ? { credentials: ctx.credentials } : {},
+        ...ctx.redirect !== void 0 ? { redirect: ctx.redirect } : {}
+      };
+      try {
+        return await ctx._fetch(ctx.url, init);
+      } catch (err) {
+        if (isIllegalInvocation(err) && typeof globalThis.fetch === "function") {
+          return await globalThis.fetch(ctx.url, init);
+        }
+        throw err;
+      }
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+  const pipeline = composeGuards(baseGuards, terminal);
+  async function request(method, path, ro) {
+    const requestUrl = withQuery(joinUrl(draft.baseUrl, path), ro?.query);
+    const headers = createHeaders();
+    if (draft.defaults?.headers) for (const [k, v] of Object.entries(draft.defaults.headers)) headers.set(k, v);
+    if (ro?.headers) {
+      for (const [k, v] of Object.entries(ro.headers)) if (v !== void 0) headers.set(k, v);
+    }
+    let body;
+    let bodyForKey = void 0;
+    if (ro?.json !== void 0) {
+      if (!headers.has("content-type")) headers.set("content-type", "application/json");
+      if (!headers.has("accept")) headers.set("accept", "application/json");
+      body = JSON.stringify(ro.json);
+      bodyForKey = ro.json;
+    } else if (ro?.body !== void 0) {
+      body = ro.body;
+      bodyForKey = "[body]";
+      if (!headers.has("accept")) headers.set("accept", "application/json");
+    } else {
+      if (!headers.has("accept")) headers.set("accept", "application/json");
+    }
+    const timeoutMs = ro?.timeoutMs ?? draft.defaults?.timeoutMs;
+    const notifier = ro?.notifier ?? defaultNotifier;
+    const emit = (event) => {
+      const redact = notifier.redact;
+      const n = notifier.notify?.bind(notifier) ?? defaultNotifier.notify.bind(defaultNotifier);
+      return n(redact ? redact(event) : event);
+    };
+    const cacheOpts = ro?.cache;
+    const wantsCache = method === "GET" && !!cache && !!cacheOpts;
+    const dedupe = cacheOpts?.dedupe ?? true;
+    const canDedupeWrite = method !== "GET" && !!ro?.idempotencyKey;
+    const inflightKey = (wantsCache || canDedupeWrite) && dedupe ? makeCacheKey({
+      method,
+      url: requestUrl,
+      headers,
+      ...method === "GET" ? {} : { body: bodyForKey },
+      ...ro?.idempotencyKey !== void 0 ? { idempotencyKey: ro.idempotencyKey } : {},
+      ...cacheOpts?.key !== void 0 ? { keyOverride: cacheOpts.key } : {}
+    }) : void 0;
+    if (inflightKey) {
+      const existing = inFlight.get(inflightKey);
+      if (existing) {
+        try {
+          const stored = await existing;
+          return asClientResult(stored, requestUrl, draft, ro, notifier, shouldNotify, emit);
+        } catch {
+        }
+      }
+    }
+    const promise = (async () => {
+      if (wantsCache) {
+        const key = inflightKey;
+        const cached = cache.get(key);
+        const policy = cacheOpts?.policy ?? "cacheFirst";
+        if (cached) {
+          if (policy === "networkOnly") ; else if (policy === "staleWhileRevalidate") {
+            void refreshInBackground(key);
+            return { kind: "cache-hit", url: requestUrl, status: 200, headers: new Headers(), raw: cached.value };
+          } else if (policy === "cacheOnly" || policy === "cacheFirst") {
+            return { kind: "cache-hit", url: requestUrl, status: 200, headers: new Headers(), raw: cached.value };
+          }
+        } else if (policy === "cacheOnly") {
+          return { kind: "cache-miss", url: requestUrl, status: 0, headers: new Headers(), raw: null };
+        }
+      }
+      const res = await fetchWithRedirects({
+        opts: draft,
+        resolvedFetch,
+        pipeline,
+        method,
+        url: requestUrl,
+        headers,
+        ...body !== void 0 ? { body } : {},
+        ...ro?.signal ? { signal: ro.signal } : {},
+        ...timeoutMs !== void 0 ? { timeoutMs } : {},
+        ...ro?.noAuth ? { noAuth: true } : {}
+      });
+      const raw = await decodeResponse(res);
+      const envelope = { kind: "network", url: res.url || requestUrl, status: res.status, headers: res.headers, raw };
+      if (wantsCache && cacheOpts && res.ok) {
+        const key = inflightKey;
+        cache.set(key, {
+          expiresAt: Date.now() + cacheOpts.ttlMs,
+          value: raw,
+          ...cacheOpts.tags ? { tags: cacheOpts.tags } : {}
+        });
+      }
+      return envelope;
+      async function refreshInBackground(key) {
+        try {
+          const res2 = await fetchWithRedirects({
+            opts: draft,
+            resolvedFetch,
+            pipeline,
+            method,
+            url: requestUrl,
+            headers,
+            ...body !== void 0 ? { body } : {},
+            ...ro?.signal ? { signal: ro.signal } : {},
+            ...timeoutMs !== void 0 ? { timeoutMs } : {},
+            ...ro?.noAuth ? { noAuth: true } : {}
+          });
+          if (!res2.ok) return;
+          const raw2 = await decodeResponse(res2);
+          cache.set(key, {
+            expiresAt: Date.now() + cacheOpts.ttlMs,
+            value: raw2,
+            ...cacheOpts.tags ? { tags: cacheOpts.tags } : {}
+          });
+        } catch {
+        }
+      }
+    })();
+    if (inflightKey) inFlight.set(inflightKey, promise);
+    try {
+      const stored = await promise;
+      return asClientResult(stored, requestUrl, draft, ro, notifier, shouldNotify, emit);
+    } catch (e) {
+      const err = e instanceof TimeoutError ? e : new NetworkError(
+        isIllegalInvocation(e) ? `Network request failed. ${ILLEGAL_INVOCATION_HINT}` : "Network request failed",
+        e
+      );
+      if (shouldNotify({ ok: false, status: 0 })) emit({ type: "network-error", level: "error", title: "Network error", message: err.message, url: requestUrl });
+      return { ok: false, status: 0, headers: new Headers(), errors: [{ message: err.message, details: e }], raw: null, url: requestUrl };
+    }
+  }
+  return {
+    get: (path, ro) => request("GET", path, ro),
+    post: (path, ro) => request("POST", path, ro),
+    put: (path, ro) => request("PUT", path, ro),
+    patch: (path, ro) => request("PATCH", path, ro),
+    delete: (path, ro) => request("DELETE", path, ro),
+    cache: { invalidateByTag: (tag) => cache?.invalidateByTag(tag) ?? 0, clear: () => cache?.clear() }
+  };
+}
+async function fetchWithRedirects(args) {
+  const policy = args.opts.redirects ?? { mode: "follow", maxHops: 5 };
+  const maxHops = policy.maxHops ?? 5;
+  if (policy.mode === "follow") return args.pipeline(makeCtx(args, "follow"));
+  if (policy.mode === "error") return args.pipeline(makeCtx(args, "error"));
+  let currentUrl = args.url;
+  let method = args.method;
+  let body = args.body;
+  for (let hop = 0; hop <= maxHops; hop++) {
+    const res = await args.pipeline(
+      makeCtx({
+        ...args,
+        url: currentUrl,
+        method,
+        ...body !== void 0 ? { body } : {}
+      }, "manual")
+    );
+    if (!REDIRECT_STATUSES.has(res.status)) return res;
+    const loc = res.headers.get("location");
+    if (!loc) {
+      return args.pipeline(
+        makeCtx(
+          {
+            ...args,
+            url: currentUrl,
+            method,
+            ...body !== void 0 ? { body } : {}
+          },
+          "follow"
+        )
+      );
+    }
+    const nextUrl = new URL(loc, currentUrl).toString();
+    const decision = policy.onRedirect?.({ fromUrl: currentUrl, toUrl: nextUrl, status: res.status, hop, method });
+    if (decision?.action === "deny") throw new RedirectError(decision.reason ?? "Redirect denied by policy", currentUrl, nextUrl);
+    const finalUrl = decision?.action === "modify" ? decision.url : nextUrl;
+    stripAuthOnCrossOriginRedirect(args.opts, args.url, finalUrl, args.headers);
+    if (res.status === 303) {
+      method = "GET";
+      body = void 0;
+    } else if ((res.status === 301 || res.status === 302) && method !== "GET") {
+      method = "GET";
+      body = void 0;
+    }
+    currentUrl = finalUrl;
+    if (hop === maxHops) throw new RedirectError(`Too many redirects (>${maxHops})`, args.url, currentUrl);
+  }
+  return args.pipeline(makeCtx(args, "manual"));
+}
+function stripAuthOnCrossOriginRedirect(opts, initialUrl, toUrl, headers) {
+  try {
+    const initialOrigin = new URL(initialUrl).origin;
+    const toOrigin = new URL(toUrl).origin;
+    if (initialOrigin === toOrigin) return;
+    if (opts.auth.mode === "bearer") {
+      const headerName = opts.auth.headerName ?? "Authorization";
+      headers.delete(headerName);
+      return;
+    }
+    if (opts.auth.mode === "basic") {
+      const headerName = opts.auth.headerName ?? "Authorization";
+      headers.delete(headerName);
+      return;
+    }
+    if (opts.auth.mode === "apiKey") {
+      const headerName = opts.auth.headerName ?? "X-API-Key";
+      headers.delete(headerName);
+      return;
+    }
+  } catch {
+  }
+}
+function makeCtx(args, redirect) {
+  const baseOrigin = (() => {
+    try {
+      return new URL(args.opts.baseUrl).origin;
+    } catch {
+      return "";
+    }
+  })();
+  return {
+    baseUrl: args.opts.baseUrl,
+    baseOrigin,
+    method: args.method,
+    url: args.url,
+    headers: args.headers,
+    ...args.body !== void 0 ? { body: args.body } : {},
+    ...args.signal ? { signal: args.signal } : {},
+    ...args.timeoutMs !== void 0 ? { timeoutMs: args.timeoutMs } : {},
+    ...args.noAuth ? { noAuth: true } : {},
+    attempt: 0,
+    auth: args.opts.auth,
+    redirect,
+    _fetch: args.resolvedFetch
+  };
+}
+async function decodeResponse(res) {
+  if (res.status === 204) return null;
+  const ct = res.headers.get("content-type") ?? "";
+  if (ct.includes("application/json")) {
+    try {
+      return await res.json();
+    } catch (e) {
+      throw new ParseError("Failed to parse JSON response", void 0, e);
+    }
+  }
+  try {
+    return await res.text();
+  } catch (e) {
+    throw new ParseError("Failed to read response body", void 0, e);
+  }
+}
+function asClientResult(envelope, requestUrl, opts, ro, notifier, shouldNotify, emit) {
+  if (envelope?.kind === "cache-miss") {
+    const errors2 = [{ message: "Cache miss" }];
+    if (shouldNotify({ ok: false, status: 0 })) emit({ type: "http-error", level: "warning", title: "Cache", message: "Cache miss", status: 0, errors: errors2, url: requestUrl });
+    return { ok: false, status: 0, headers: new Headers(), errors: errors2, raw: envelope.raw, url: requestUrl };
+  }
+  const status = envelope.status ?? 0;
+  const raw = envelope.raw;
+  const resHeaders = envelope.headers ?? new Headers();
+  const finalUrl = envelope.url ?? requestUrl;
+  const okByParser = opts.parser.isSuccess(raw, status);
+  if (okByParser && status >= 200 && status < 400) {
+    const dataRaw = opts.parser.getData(raw);
+    try {
+      const data = ro?.dataSchema ? ro.dataSchema.parse(dataRaw) : dataRaw;
+      return { ok: true, status, headers: resHeaders, data, raw, url: finalUrl };
+    } catch (e) {
+      const msg2 = e instanceof Error ? e.message : "Schema parse failed";
+      if (shouldNotify({ ok: false, status })) emit({ type: "parse-error", level: "error", title: "Parse error", message: msg2, url: finalUrl });
+      return { ok: false, status, headers: resHeaders, errors: [{ message: msg2, details: e }], raw, url: finalUrl };
+    }
+  }
+  const errors = opts.parser.getErrors(raw, status);
+  const msg = errors[0]?.message ?? (status ? `HTTP ${status}` : "Request failed");
+  if (shouldNotify({ ok: false, status })) emit({ type: "http-error", level: status >= 500 ? "error" : "warning", title: "Request failed", message: msg, status, errors, url: finalUrl });
+  return { ok: false, status, headers: resHeaders, errors, raw, url: finalUrl };
+}
+function anySignal(signals) {
+  const valid = signals.filter(Boolean);
+  const any = AbortSignal.any;
+  if (any) {
+    try {
+      return any(valid);
+    } catch {
+    }
+  }
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  for (const s of valid) {
+    if (s.aborted) controller.abort();
+    s.addEventListener("abort", onAbort, { once: true });
+  }
+  return controller.signal;
+}
+
+// src/auth/authConfig.ts
+function bearerAuth(getToken, opts) {
+  return {
+    mode: "bearer",
+    getToken,
+    ...opts?.headerName !== void 0 ? { headerName: opts.headerName } : {},
+    ...opts?.prefix !== void 0 ? { prefix: opts.prefix } : {},
+    ...opts?.allowedOrigins !== void 0 ? { allowedOrigins: opts.allowedOrigins } : {}
+  };
+}
+function cookieAuth(opts) {
+  return {
+    mode: "cookie",
+    ...opts?.credentials !== void 0 ? { credentials: opts.credentials } : {},
+    ...opts?.csrf !== void 0 ? { csrf: opts.csrf } : {}
+  };
+}
+function basicAuth(getCredentials, opts) {
+  return {
+    mode: "basic",
+    getCredentials,
+    ...opts?.headerName !== void 0 ? { headerName: opts.headerName } : {},
+    ...opts?.prefix !== void 0 ? { prefix: opts.prefix } : {},
+    ...opts?.allowedOrigins !== void 0 ? { allowedOrigins: opts.allowedOrigins } : {}
+  };
+}
+function apiKeyAuth(getKey, opts) {
+  return {
+    mode: "apiKey",
+    getKey,
+    ...opts?.headerName !== void 0 ? { headerName: opts.headerName } : {},
+    ...opts?.prefix !== void 0 ? { prefix: opts.prefix } : {},
+    ...opts?.allowedOrigins !== void 0 ? { allowedOrigins: opts.allowedOrigins } : {}
+  };
+}
+function noAuth() {
+  return { mode: "none" };
+}
+
+// src/guards/retryGuard.ts
+function retryGuard(opts) {
+  const retries = opts?.retries ?? 0;
+  const retryOn = new Set(opts?.retryOn ?? [502, 503, 504]);
+  const baseDelay = opts?.baseDelayMs ?? 150;
+  const maxDelay = opts?.maxDelayMs ?? 1500;
+  return async (ctx, next) => {
+    let last;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      ctx.attempt = attempt;
+      last = await next(ctx);
+      if (!retryOn.has(last.status)) return last;
+      if (attempt === retries) return last;
+      const delay = Math.min(maxDelay, baseDelay * 2 ** attempt);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+    return last;
+  };
+}
+
+// src/guards/cookieSafeRefreshGuard.ts
+var REFRESH_FLAG = "__hg_is_refresh__";
+var RETRY_FLAG = "__hg_refresh_retry__";
+function isReplayableBody(body) {
+  if (body == null) return true;
+  if (typeof body === "string") return true;
+  if (typeof Blob !== "undefined" && body instanceof Blob) return true;
+  if (typeof FormData !== "undefined" && body instanceof FormData) return true;
+  if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return true;
+  if (typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer) return true;
+  if (typeof Uint8Array !== "undefined" && body instanceof Uint8Array) return true;
+  return false;
+}
+function normalizePath(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    const q = url.indexOf("?");
+    const h = url.indexOf("#");
+    const cut = Math.min(q === -1 ? url.length : q, h === -1 ? url.length : h);
+    return url.slice(0, cut);
+  }
+}
+function parseRetryAfterMs(headers) {
+  const ra = headers.get("retry-after");
+  if (!ra) return null;
+  const seconds = Number(ra);
+  if (!Number.isNaN(seconds) && seconds >= 0) return seconds * 1e3;
+  const date = Date.parse(ra);
+  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  return null;
+}
+function isAbsoluteUrl(u) {
+  try {
+    void new URL(u);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cookieSafeRefreshGuard(opts) {
+  const trigger = new Set(opts.triggerStatuses ?? [401, 419]);
+  const maxRetry = opts.maxRetry ?? 1;
+  const honorRetryAfter = opts.honorRetryAfter ?? true;
+  let refreshPromise = null;
+  let refreshCooldownUntil = 0;
+  return async (ctx, next) => {
+    const anyCtx = ctx;
+    if (anyCtx[REFRESH_FLAG]) return next(ctx);
+    const path = normalizePath(ctx.url);
+    if (opts.excludePaths?.includes(path)) return next(ctx);
+    if (ctx.noAuth) return next(ctx);
+    const refreshPathNorm = normalizePath(resolveRefreshUrl(ctx, opts.refreshPath));
+    if (path === refreshPathNorm) return next(ctx);
+    if (honorRetryAfter && refreshCooldownUntil > Date.now()) {
+      return next(ctx);
+    }
+    const res = await next(ctx);
+    if (!trigger.has(res.status)) return res;
+    if (opts.shouldRefresh && !opts.shouldRefresh(ctx, res.status)) return res;
+    const alreadyRetried = Number(anyCtx[RETRY_FLAG] ?? 0);
+    if (alreadyRetried >= maxRetry) return res;
+    if (!isReplayableBody(ctx.body)) return res;
+    const decision = await (refreshPromise ??= doRefresh(ctx, next).finally(() => {
+      refreshPromise = null;
+    }));
+    if (!decision.ok) {
+      opts.onRefreshFailed?.({
+        url: ctx.url,
+        ...decision.reason !== void 0 ? { reason: decision.reason } : {},
+        ...decision.status !== void 0 ? { status: decision.status } : {}
+      });
+      return res;
+    }
+    opts.onRefreshSuccess?.({ url: ctx.url });
+    const retryCtx = Object.assign({}, ctx, { attempt: ctx.attempt + 1 });
+    retryCtx[RETRY_FLAG] = alreadyRetried + 1;
+    await applyCookieAuth(retryCtx);
+    return next(retryCtx);
+  };
+  async function doRefresh(originalCtx, next) {
+    if (honorRetryAfter && refreshCooldownUntil > Date.now()) {
+      return { ok: false, reason: "Refresh cooldown active" };
+    }
+    const refreshUrl = resolveRefreshUrl(originalCtx, opts.refreshPath);
+    const refreshCtx = {
+      ...originalCtx,
+      url: refreshUrl,
+      method: opts.refreshMethod ?? "POST",
+      // Un refresh n’a en général pas besoin du body original
+      ...Object.prototype.hasOwnProperty.call(originalCtx, "body") ? { body: void 0 } : {},
+      attempt: 0
+    };
+    refreshCtx[REFRESH_FLAG] = true;
+    refreshCtx[RETRY_FLAG] = 0;
+    await applyCookieAuth(refreshCtx);
+    try {
+      const res = await next(refreshCtx);
+      if (res.status === 429 && honorRetryAfter) {
+        const ms = parseRetryAfterMs(res.headers);
+        refreshCooldownUntil = Date.now() + (ms ?? 3e4);
+        return { ok: false, reason: "Refresh rate-limited (429)", status: 429 };
+      }
+      if (!res.ok) {
+        return { ok: false, reason: `Refresh failed (HTTP ${res.status})`, status: res.status };
+      }
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, reason: e instanceof Error ? e.message : "Refresh exception" };
+    }
+  }
+  function resolveRefreshUrl(ctx, refreshPath) {
+    if (isAbsoluteUrl(refreshPath)) return refreshPath;
+    return joinUrl(ctx.baseUrl, refreshPath);
+  }
+  async function applyCookieAuth(ctx) {
+    if (ctx.noAuth) return;
+    const auth = ctx.auth;
+    if (!auth || auth.mode !== "cookie") return;
+    if (ctx.credentials === void 0) {
+      ctx.credentials = auth.credentials ?? "include";
+    }
+    if (auth.csrf) {
+      const hn = auth.csrf.headerName;
+      if (!ctx.headers.has(hn)) {
+        const t = await auth.csrf.getToken();
+        if (t != null && String(t) !== "") ctx.headers.set(hn, String(t));
+      }
+    }
+  }
+}
+
+// src/guards/unauthorizedGuard.ts
+function normalizePath2(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    const q = url.indexOf("?");
+    const h = url.indexOf("#");
+    const cut = Math.min(q === -1 ? url.length : q, h === -1 ? url.length : h);
+    return url.slice(0, cut);
+  }
+}
+function unauthorizedGuard(opts) {
+  const statuses = opts.statuses ?? [401, 419];
+  const ignoreNoAuth = opts.ignoreNoAuth ?? true;
+  const once = opts.once ?? true;
+  const cooldownMs = opts.cooldownMs ?? 250;
+  let locked = false;
+  let cooldownUntil = 0;
+  return async (ctx, next) => {
+    let res;
+    try {
+      res = await next(ctx);
+    } catch (e) {
+      throw e;
+    }
+    if (ignoreNoAuth && ctx.noAuth) return res;
+    const path = normalizePath2(ctx.url);
+    if (opts.excludePaths?.includes(path)) return res;
+    if (!statuses.includes(res.status)) return res;
+    if (opts.shouldHandle && !opts.shouldHandle(ctx, res.status)) return res;
+    const now = Date.now();
+    if (now < cooldownUntil) return res;
+    if (once) {
+      if (locked) return res;
+      locked = true;
+    }
+    try {
+      opts.onUnauthorized({ url: ctx.url, status: res.status });
+    } finally {
+      cooldownUntil = Date.now() + cooldownMs;
+      if (once) setTimeout(() => locked = false, cooldownMs);
+    }
+    return res;
+  };
+}
+
+// src/guards/instrumentGuard.ts
+var REFRESH_FLAG2 = "__hg_is_refresh__";
+var RETRY_FLAG2 = "__hg_refresh_retry__";
+function safeUrl(u) {
+  try {
+    const url = new URL(u);
+    return url.toString();
+  } catch {
+    return u;
+  }
+}
+function nowMs() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function headersToObject(h) {
+  if (!h) return {};
+  const out = {};
+  try {
+    h.forEach((v, k) => {
+      const key = String(k).toLowerCase();
+      if (key === "authorization" || key === "cookie" || key === "set-cookie" || key === "x-api-key" || key === "proxy-authorization") {
+        out[k] = "[REDACTED]";
+      } else {
+        out[k] = v;
+      }
+    });
+  } catch {
+  }
+  return out;
+}
+var __hg_req_seq = 0;
+function instrumentGuard(opts, guard) {
+  const log = opts.log ?? ((line, data) => data !== void 0 ? console.log(line, data) : console.log(line));
+  return async (ctx, next) => {
+    const id = ++__hg_req_seq;
+    const t0 = nowMs();
+    const url = safeUrl(ctx.url);
+    const method = ctx.method ?? "GET";
+    if (opts.include && !opts.include.test(url)) {
+      return guard(ctx, next);
+    }
+    if (opts.exclude && opts.exclude.test(url)) {
+      return guard(ctx, next);
+    }
+    const anyCtx = ctx;
+    const attempt = ctx.attempt ?? 0;
+    const isRefresh = Boolean(anyCtx[REFRESH_FLAG2]);
+    const retryCount = Number(anyCtx[RETRY_FLAG2] ?? 0);
+    const noAuth2 = Boolean(ctx.noAuth);
+    const baseLine = `[HG][#${id}][${opts.name}]`;
+    log(`${baseLine} \u25B6 start`, {
+      method,
+      url,
+      attempt,
+      retryCount,
+      isRefresh,
+      noAuth: noAuth2,
+      baseUrl: ctx.baseUrl,
+      ...opts.logInit ? {
+        credentials: ctx.credentials,
+        redirect: ctx.redirect,
+        headers: headersToObject(ctx.headers)
+      } : {},
+      ...opts.stack ? { stack: new Error().stack } : {}
+    });
+    try {
+      const res = await guard(ctx, next);
+      const dt = Math.round(nowMs() - t0);
+      log(`${baseLine} \u25C0 end (${dt}ms)`, {
+        status: res.status,
+        ok: res.ok,
+        url: res.url || url,
+        redirected: res.redirected,
+        location: res.headers?.get?.("location") ?? null,
+        retryAfter: res.headers?.get?.("retry-after") ?? null
+      });
+      return res;
+    } catch (e) {
+      const dt = Math.round(nowMs() - t0);
+      log(`${baseLine} \u2716 throw (${dt}ms)`, {
+        error: e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : e
+      });
+      throw e;
+    }
+  };
+}
+
+// src/cache/memoryCache.ts
+function memoryCache(opts) {
+  const max = opts?.maxEntries ?? 1e3;
+  const map = /* @__PURE__ */ new Map();
+  const tagIndex = /* @__PURE__ */ new Map();
+  function touch(key) {
+    const v = map.get(key);
+    if (!v) return;
+    map.delete(key);
+    map.set(key, v);
+  }
+  function deindexTags(key, entry) {
+    const tags = entry?.tags;
+    if (!tags?.length) return;
+    for (const t of tags) {
+      const set = tagIndex.get(t);
+      if (!set) continue;
+      set.delete(key);
+      if (set.size === 0) tagIndex.delete(t);
+    }
+  }
+  function indexTags(key, tags) {
+    if (!tags?.length) return;
+    for (const t of tags) {
+      let set = tagIndex.get(t);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        tagIndex.set(t, set);
+      }
+      set.add(key);
+    }
+  }
+  function del(key) {
+    const prev = map.get(key);
+    if (prev) deindexTags(key, prev);
+    map.delete(key);
+  }
+  function ensureLimit() {
+    while (map.size > max) {
+      const firstKey = map.keys().next().value;
+      if (!firstKey) break;
+      del(firstKey);
+    }
+  }
+  return {
+    get(key) {
+      const entry = map.get(key);
+      if (!entry) return void 0;
+      if (Date.now() > entry.expiresAt) {
+        del(key);
+        return void 0;
+      }
+      touch(key);
+      return entry;
+    },
+    set(key, entry) {
+      const prev = map.get(key);
+      if (prev) deindexTags(key, prev);
+      map.set(key, entry);
+      indexTags(key, entry.tags);
+      ensureLimit();
+    },
+    delete: del,
+    invalidateByTag(tag) {
+      const set = tagIndex.get(tag);
+      if (!set) return 0;
+      const keys = Array.from(set);
+      let n = 0;
+      for (const k of keys) {
+        if (map.has(k)) {
+          del(k);
+          n++;
+        }
+      }
+      return n;
+    },
+    clear() {
+      map.clear();
+      tagIndex.clear();
+    }
+  };
+}
+
+// src/parsing/shapeParser.ts
+function createShapeParser(p) {
+  return p;
+}
+
+// src/parsing/schemaAdapter.ts
+function schema(impl) {
+  return impl;
+}
+function fromZod(zodSchema) {
+  if (typeof zodSchema.parse === "function") return { parse: (i) => zodSchema.parse(i) };
+  if (typeof zodSchema.safeParse === "function") {
+    return {
+      parse: (i) => {
+        const r = zodSchema.safeParse(i);
+        if (r && r.success) return r.data;
+        throw new Error("Schema validation failed");
+      }
+    };
+  }
+  throw new Error("Unsupported zod-like schema: expected parse or safeParse");
+}
+
+// src/parsing/presets.ts
+function createApiParserRestClassic(opts) {
+  const successField = opts?.successField ?? "success";
+  const dataField = opts?.dataField ?? "data";
+  const errorField = opts?.errorField ?? "error";
+  const messageField = opts?.messageField ?? "message";
+  return createShapeParser({
+    isSuccess: (raw, status) => {
+      if (raw && typeof raw === "object" && successField in raw) return Boolean(raw[successField]);
+      return status >= 200 && status < 400;
+    },
+    getData: (raw) => raw && typeof raw === "object" && dataField in raw ? raw[dataField] : raw,
+    getErrors: (raw, status) => {
+      if (!raw || typeof raw !== "object") return status ? [{ message: `HTTP ${status}` }] : [{ message: "Request failed" }];
+      const r = raw;
+      const err = r[errorField] ?? r[messageField] ?? r["errors"];
+      if (!err) return status ? [{ message: `HTTP ${status}` }] : [{ message: "Request failed" }];
+      if (typeof err === "string") return [{ message: err }];
+      if (Array.isArray(err)) return err.map((e) => ({ message: String(e) }));
+      if (typeof err === "object") {
+        if (typeof err.message === "string") return [{ message: err.message, ...err.code ? { code: String(err.code) } : {}, details: err }];
+        return [{ message: String(r[messageField] ?? "Request failed"), details: err }];
+      }
+      return [{ message: String(err) }];
+    }
+  });
+}
+function createApiParserLaravel(opts) {
+  const dataField = opts?.dataField ?? "data";
+  return createShapeParser({
+    isSuccess: (_raw, status) => status >= 200 && status < 400,
+    getData: (raw) => raw && typeof raw === "object" && dataField in raw ? raw[dataField] : raw,
+    getErrors: (raw, status) => laravelErrors(raw, status)
+  });
+}
+function laravelErrors(raw, status) {
+  if (!raw || typeof raw !== "object") return status ? [{ message: `HTTP ${status}` }] : [{ message: "Request failed" }];
+  const r = raw;
+  if (r.errors && typeof r.errors === "object") {
+    const out = [];
+    for (const [field, msgs] of Object.entries(r.errors)) {
+      if (Array.isArray(msgs)) for (const m of msgs) out.push({ field, message: String(m) });
+      else out.push({ field, message: String(msgs) });
+    }
+    if (out.length) return out;
+  }
+  const msg = typeof r.message === "string" ? r.message : status ? `HTTP ${status}` : "Request failed";
+  return [{ message: msg, details: r }];
+}
+function createApiParserNest() {
+  return createShapeParser({
+    isSuccess: (_raw, status) => status >= 200 && status < 400,
+    getData: (raw) => raw,
+    getErrors: (raw, status) => nestErrors(raw, status)
+  });
+}
+function nestErrors(raw, status) {
+  if (!raw || typeof raw !== "object") return status ? [{ message: `HTTP ${status}` }] : [{ message: "Request failed" }];
+  const r = raw;
+  const msg = r.message;
+  if (Array.isArray(msg)) return msg.map((m) => ({ message: String(m), details: r }));
+  if (typeof msg === "string") return [{ message: msg, ...r.error ? { code: String(r.error) } : {}, details: r }];
+  return [{ message: status ? `HTTP ${status}` : "Request failed", details: r }];
+}
+function createApiParserGraphQL(opts) {
+  const allowPartial = opts?.allowPartialData ?? false;
+  return createShapeParser({
+    isSuccess: (raw, status) => {
+      if (status < 200 || status >= 400) return false;
+      if (!raw || typeof raw !== "object") return false;
+      const r = raw;
+      const hasErrors = Array.isArray(r.errors) && r.errors.length > 0;
+      if (hasErrors && !allowPartial) return false;
+      return "data" in r;
+    },
+    getData: (raw) => raw && typeof raw === "object" ? raw.data : raw,
+    getErrors: (raw, status) => {
+      if (!raw || typeof raw !== "object") return status ? [{ message: `HTTP ${status}` }] : [{ message: "GraphQL request failed" }];
+      const r = raw;
+      const errs = Array.isArray(r.errors) ? r.errors : [];
+      if (!errs.length) return status >= 400 ? [{ message: `HTTP ${status}` }] : [{ message: "GraphQL request failed" }];
+      return errs.map((e) => ({
+        message: typeof e?.message === "string" ? e.message : "GraphQL error",
+        code: e?.extensions?.code ? String(e.extensions.code) : void 0,
+        details: e
+      }));
+    }
+  });
+}
+
+// src/presets/presetBuilder.ts
+function createPresetBuilder(init) {
+  const state = {
+    baseUrl: init?.baseUrl ?? "",
+    parser: init?.parser ?? createApiParserRestClassic(),
+    auth: init?.auth ?? noAuth(),
+    ...init?.fetch ? { fetch: init.fetch } : {},
+    ...init?.notifier ? { notifier: init.notifier } : { notifier: consoleNotifier },
+    guards: []
+  };
+  function ensureBaseUrl() {
+    if (!state.baseUrl) throw new Error("presetBuilder: baseUrl is required");
+  }
+  const api = {
+    /** Set / override baseUrl */
+    baseUrl(baseUrl) {
+      state.baseUrl = baseUrl;
+      return api;
+    },
+    /** Set / override parser */
+    parser(parser) {
+      state.parser = parser;
+      return api;
+    },
+    /** Set / override fetch */
+    fetch(fetchImpl) {
+      state.fetch = fetchImpl;
+      return api;
+    },
+    /** Set / override notifier */
+    notifier(notifier) {
+      state.notifier = notifier;
+      return api;
+    },
+    /** Add guard(s) (preserves order) */
+    guards(...guards) {
+      state.guards = [...state.guards ?? [], ...guards];
+      return api;
+    },
+    /** Enable in-memory cache */
+    memoryCache(opts) {
+      state.cache = memoryCache(opts);
+      return api;
+    },
+    /** Low-level cache assignment */
+    cache(cache) {
+      if (cache === void 0) {
+        delete state.cache;
+      } else {
+        state.cache = cache;
+      }
+      return api;
+    },
+    /** Default headers / timeouts / notify policy */
+    defaults(defaults) {
+      state.defaults = { ...state.defaults ?? {}, ...defaults ?? {} };
+      return api;
+    },
+    /** Redirect policy */
+    redirects(redirects) {
+      if (redirects === void 0) {
+        delete state.redirects;
+      } else {
+        state.redirects = redirects;
+      }
+      return api;
+    },
+    /** Auth presets */
+    auth(auth) {
+      state.auth = auth;
+      return api;
+    },
+    bearer(getToken, opts) {
+      state.auth = bearerAuth(getToken, opts);
+      return api;
+    },
+    cookie(opts) {
+      state.auth = cookieAuth(opts);
+      return api;
+    },
+    basic(getCred, opts) {
+      state.auth = basicAuth(getCred, opts);
+      return api;
+    },
+    apiKey(getKey, opts) {
+      state.auth = apiKeyAuth(getKey, opts);
+      return api;
+    },
+    none() {
+      state.auth = noAuth();
+      return api;
+    },
+    /**
+     * Cookie refresh guard preset (only meaningful for cookie auth).
+     * You can still add it manually via `.guards(...)`.
+     */
+    cookieRefresh(opts) {
+      state.guards = [...state.guards ?? [], cookieSafeRefreshGuard(opts)];
+      return api;
+    },
+    /** Unauthorized handler preset (redirect/logout). */
+    unauthorized(opts) {
+      state.guards = [...state.guards ?? [], unauthorizedGuard(opts)];
+      return api;
+    },
+    /** Returns the final HttpClientOptions */
+    options() {
+      ensureBaseUrl();
+      return { ...state, guards: [...state.guards ?? []] };
+    },
+    /** Creates the http client */
+    create() {
+      ensureBaseUrl();
+      return createHttpClient(api.options());
+    }
+  };
+  return api;
+}
+function createSimpleClient(opts) {
+  return createPresetBuilder(opts).create();
+}
+function createBearerClient(opts) {
+  const bearerOpts = {
+    ...opts.headerName !== void 0 ? { headerName: opts.headerName } : {},
+    ...opts.prefix !== void 0 ? { prefix: opts.prefix } : {}
+  };
+  return createPresetBuilder({
+    baseUrl: opts.baseUrl,
+    ...opts.parser ? { parser: opts.parser } : {},
+    ...opts.fetch ? { fetch: opts.fetch } : {},
+    ...opts.notifier ? { notifier: opts.notifier } : {}
+  }).bearer(opts.getToken, Object.keys(bearerOpts).length ? bearerOpts : void 0).create();
+}
+function createCookieClient(opts) {
+  const b = createPresetBuilder({
+    baseUrl: opts.baseUrl,
+    ...opts.parser ? { parser: opts.parser } : {},
+    ...opts.fetch ? { fetch: opts.fetch } : {},
+    ...opts.notifier ? { notifier: opts.notifier } : {}
+  }).cookie({
+    ...opts.credentials !== void 0 ? { credentials: opts.credentials } : {},
+    ...opts.csrf !== void 0 ? { csrf: opts.csrf } : {}
+  });
+  if (opts.refresh) b.cookieRefresh(opts.refresh);
+  return b.create();
+}
+function createBasicClient(opts) {
+  const basicOpts = {
+    ...opts.headerName !== void 0 ? { headerName: opts.headerName } : {},
+    ...opts.prefix !== void 0 ? { prefix: opts.prefix } : {}
+  };
+  return createPresetBuilder({
+    baseUrl: opts.baseUrl,
+    ...opts.parser ? { parser: opts.parser } : {},
+    ...opts.fetch ? { fetch: opts.fetch } : {},
+    ...opts.notifier ? { notifier: opts.notifier } : {}
+  }).basic(opts.getCredentials, Object.keys(basicOpts).length ? basicOpts : void 0).create();
+}
+function createApiKeyClient(opts) {
+  const apiKeyOpts = {
+    ...opts.headerName !== void 0 ? { headerName: opts.headerName } : {},
+    ...opts.prefix !== void 0 ? { prefix: opts.prefix } : {}
+  };
+  return createPresetBuilder({
+    baseUrl: opts.baseUrl,
+    ...opts.parser ? { parser: opts.parser } : {},
+    ...opts.fetch ? { fetch: opts.fetch } : {},
+    ...opts.notifier ? { notifier: opts.notifier } : {}
+  }).apiKey(opts.getKey, Object.keys(apiKeyOpts).length ? apiKeyOpts : void 0).create();
+}
+
+// src/aliases.ts
+function createClient(opts) {
+  const parser = opts.parser ?? createApiParserRestClassic();
+  const auth = opts.auth ?? noAuth();
+  const notifier = opts.notifier ?? consoleNotifier;
+  const cfg = {
+    baseUrl: opts.baseUrl,
+    parser,
+    auth,
+    notifier,
+    ...opts.fetch ? { fetch: opts.fetch } : {},
+    ...opts.defaults ? { defaults: opts.defaults } : {},
+    ...opts.cache ? { cache: opts.cache } : {},
+    ...opts.redirects ? { redirects: opts.redirects } : {},
+    ...opts.guards ? { guards: opts.guards } : {}
+  };
+  return createHttpClient(cfg);
+}
+
+exports.ILLEGAL_INVOCATION_HINT = ILLEGAL_INVOCATION_HINT;
+exports.NetworkError = NetworkError;
+exports.ParseError = ParseError;
+exports.RedirectError = RedirectError;
+exports.TimeoutError = TimeoutError;
+exports.alertNotifier = alertNotifier;
+exports.apiKeyAuth = apiKeyAuth;
+exports.basicAuth = basicAuth;
+exports.bearerAuth = bearerAuth;
+exports.consoleNotifier = consoleNotifier;
+exports.cookieAuth = cookieAuth;
+exports.cookieSafeRefreshGuard = cookieSafeRefreshGuard;
+exports.createApiKeyClient = createApiKeyClient;
+exports.createApiParserGraphQL = createApiParserGraphQL;
+exports.createApiParserLaravel = createApiParserLaravel;
+exports.createApiParserNest = createApiParserNest;
+exports.createApiParserRestClassic = createApiParserRestClassic;
+exports.createBasicClient = createBasicClient;
+exports.createBearerClient = createBearerClient;
+exports.createClient = createClient;
+exports.createCookieClient = createCookieClient;
+exports.createHttpClient = createHttpClient;
+exports.createPresetBuilder = createPresetBuilder;
+exports.createShapeParser = createShapeParser;
+exports.createSimpleClient = createSimpleClient;
+exports.fromZod = fromZod;
+exports.instrumentGuard = instrumentGuard;
+exports.memoryCache = memoryCache;
+exports.noAuth = noAuth;
+exports.retryGuard = retryGuard;
+exports.schema = schema;
+exports.tailwindAlertRenderer = tailwindAlertRenderer;
+exports.unauthorizedGuard = unauthorizedGuard;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map