@nxgt/httpyz 0.3.0 → 0.3.1

package/dist/integration/index.js

@@ -1,1058 +1,21 @@
-// src/cancel/abort.ts
-function isAbortError(error) {
-  if (typeof DOMException !== "undefined" && error instanceof DOMException) {
-    return error.name === "AbortError" || error.name === "TimeoutError";
-  }
-  return error instanceof Error && error.name === "AbortError";
-}
-var cancelled = (message) => new DOMException(message, "AbortError");
-function abortable(promise, signal) {
-  if (!signal)
-    return promise;
-  if (signal.aborted)
-    return Promise.reject(signal.reason);
-  return new Promise((resolve, reject) => {
-    const stop = () => reject(signal.reason);
-    signal.addEventListener("abort", stop, { once: true });
-    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", stop));
-  });
-}
-function joinSignals(...signals) {
-  const present = signals.filter((signal) => signal != null);
-  return present.length > 1 ? AbortSignal.any(present) : present[0];
-}
-
-// src/cancel/latest.ts
-function createLatest() {
-  const running = new Map;
-  return (key) => {
-    running.get(key)?.abort(cancelled(`A later call with latest: '${key}' replaced this one`));
-    const controller = new AbortController;
-    running.set(key, controller);
-    return controller.signal;
-  };
-}
-
-// src/errors/errors.ts
-class ClientError extends Error {
-  constructor(context, message, options) {
-    const route = `${context.method.toUpperCase()} ${context.path}`;
-    const call = context.operationId === undefined ? route : `${context.operationId} (${route})`;
-    super(`${call}: ${message}`, options);
-    this.name = "ClientError";
-    this.operationId = context.operationId;
-    this.method = context.method;
-    this.path = context.path;
-  }
-}
-
-class NetworkError extends ClientError {
-  constructor(context, options) {
-    super(context, "no reply came back", options);
-    this.name = "NetworkError";
-  }
-}
-
-class TimeoutError extends ClientError {
-  constructor(context, timeout, options) {
-    super(context, `no reply within ${timeout} ms`, options);
-    this.name = "TimeoutError";
-    this.timeout = timeout;
-  }
-}
-
-class UndeclaredStatusError extends ClientError {
-  constructor(context, response) {
-    super(context, `no ${response.status} reply is declared`);
-    this.name = "UndeclaredStatusError";
-    this.status = response.status;
-    this.response = response;
-  }
-}
-
-class ValidationError extends ClientError {
-  constructor(context, failure) {
-    super(context, failure.issues.map((issue) => issue.message).join("; "));
-    this.name = "ValidationError";
-    this.failure = failure;
-  }
-}
-
-class ReplyStatusError extends Error {
-  constructor(reply, expected) {
-    const wanted = expected.length > 0 ? expected.join(" or ") : "2xx";
-    super(`Expected a ${wanted} reply, got ${reply.status}`);
-    this.name = "ReplyStatusError";
-    this.status = reply.status;
-    this.data = reply.data;
-    this.response = reply.response;
-  }
-}
-
-// src/middleware/auth.ts
-function auth({
-  token,
-  refresh,
-  scheme = "Bearer"
-}) {
-  let refreshing;
-  const sign = (request, value) => {
-    if (value)
-      request.headers.set("authorization", `${scheme} ${value}`);
-    return request;
-  };
-  return async (request, next) => {
-    const used = await token();
-    const replay = refresh ? request.clone() : undefined;
-    const response = await next(sign(request, used));
-    if (response.status !== 401 || !replay || !refresh)
-      return response;
-    try {
-      if (await token() === used) {
-        refreshing ??= Promise.resolve().then(refresh).finally(() => {
-          refreshing = undefined;
-        });
-        await abortable(refreshing, request.signal);
-      }
-    } catch (error) {
-      if (request.signal.aborted) {
-        await response.body?.cancel();
-        throw error;
-      }
-      return response;
-    }
-    const fresh = await token();
-    if (!fresh || fresh === used)
-      return response;
-    await response.body?.cancel();
-    return next(sign(replay, fresh));
-  };
-}
-
-// src/middleware/compose.ts
-var compose = (middlewares, send, call) => middlewares.reduceRight((next, middleware) => (request) => middleware(request, next, call), send);
-
-// src/middleware/retry.ts
-var REPEATABLE = [
-  "get",
-  "head",
-  "options",
-  "put",
-  "delete",
-  "trace",
-  "query"
-];
-var TRANSIENT = [408, 429, 502, 503, 504];
-var backoff = (attempt) => Math.random() * 300 * 2 ** (attempt - 1);
-function retrySettings(retry) {
-  if (retry === undefined || retry === false)
-    return;
-  const options = typeof retry === "number" ? { attempts: retry } : retry;
-  const attempts = options.attempts ?? 2;
-  if (attempts <= 0)
-    return;
-  return {
-    attempts,
-    methods: options.methods ?? REPEATABLE,
-    statuses: options.statuses ?? TRANSIENT,
-    delay: options.delay ?? backoff,
-    maxDelay: options.maxDelay ?? 1e4
-  };
-}
-function retryDelay(response, attempt, settings) {
-  const header = response?.headers.get("retry-after")?.trim();
-  if (header) {
-    const wait = /^\d+(?:\.\d+)?$/.test(header) ? Number(header) * 1000 : Date.parse(header) - Date.now();
-    if (!Number.isNaN(wait)) {
-      return wait > settings.maxDelay ? undefined : Math.max(0, wait);
-    }
-  }
-  return Math.min(Math.max(0, settings.delay(attempt)), settings.maxDelay);
-}
-var sleep = (ms, signal) => new Promise((resolve, reject) => {
-  if (signal.aborted)
-    return reject(signal.reason);
-  const stop = () => {
-    clearTimeout(timer);
-    reject(signal.reason);
-  };
-  const timer = setTimeout(() => {
-    signal.removeEventListener("abort", stop);
-    resolve();
-  }, ms);
-  signal.addEventListener("abort", stop, { once: true });
-});
-function retrying(settings) {
-  return async (request, next) => {
-    const method = request.method.toLowerCase();
-    if (!settings.methods.includes(method))
-      return next(request);
-    for (let attempt = 1;; attempt++) {
-      const last = attempt > settings.attempts;
-      const sent = last ? request : request.clone();
-      let wait;
-      try {
-        const response = await next(sent);
-        if (last || !settings.statuses.includes(response.status)) {
-          return response;
-        }
-        wait = retryDelay(response, attempt, settings);
-        if (wait === undefined)
-          return response;
-        await response.body?.cancel();
-      } catch (error) {
-        if (last || !(error instanceof NetworkError))
-          throw error;
-        wait = retryDelay(undefined, attempt, settings) ?? 0;
-      }
-      await sleep(wait, request.signal);
-    }
-  };
-}
-
-// src/schema/standard-schema.ts
-async function check(schema, value, target) {
-  const result = await schema["~standard"].validate(value);
-  if (result.issues === undefined)
-    return { ok: true, value: result.value };
-  return {
-    ok: false,
-    issues: result.issues.map((issue) => {
-      const { code } = issue;
-      return {
-        target,
-        path: (issue.path ?? []).map((key) => typeof key === "object" ? key.key : key).filter((key) => typeof key !== "symbol"),
-        code: typeof code === "string" ? code : "custom",
-        message: issue.message
-      };
-    })
-  };
-}
-
-// src/reply/media-type.ts
-var mediaType = (header) => (header.split(";")[0] ?? "").trim().toLowerCase();
-function mediaKind(type) {
-  if (type === "application/json" || /^application\/[\w.-]+\+json$/.test(type)) {
-    return "json";
-  }
-  if (type === "application/x-www-form-urlencoded" || type === "multipart/form-data") {
-    return "form";
-  }
-  return type.startsWith("text/") ? "text" : "binary";
-}
-function declaredType(content, type) {
-  const types = Object.keys(content);
-  const exact = types.find((key) => key.toLowerCase() === type);
-  if (exact !== undefined)
-    return exact;
-  const range = `${type.split("/")[0]}/*`;
-  if (content[range])
-    return range;
-  if (content["*/*"])
-    return "*/*";
-  const kind = mediaKind(type);
-  if (kind !== "json" && kind !== "text")
-    return;
-  return types.find((key) => content[key]?.kind === kind);
-}
-
-// src/reply/read-reply.ts
-var isSchema = (value) => typeof value === "object" && value !== null && ("~standard" in value);
-function toSpec(responses) {
-  const spec = {};
-  for (const [status, declared] of Object.entries(responses)) {
-    const content = {};
-    if (isSchema(declared)) {
-      content["application/json"] = { kind: "json", schema: declared };
-    } else if (declared !== null) {
-      for (const [type, schema] of Object.entries(declared)) {
-        content[type] = {
-          kind: mediaKind(type.toLowerCase()),
-          ...schema === null ? {} : { schema }
-        };
-      }
-    }
-    spec[Number(status)] = content;
-  }
-  return spec;
-}
-async function readReply(context, spec, response, settings) {
-  const { status } = response;
-  const header = response.headers.get("content-type");
-  const refused = (issues) => new ValidationError(context, {
-    kind: "response",
-    ...context,
-    status,
-    issues
-  });
-  const failure = (code, message) => refused([{ target: "response", path: [], code, message }]);
-  const parse = (text) => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      throw failure("invalid_json", `the ${status} reply is not valid JSON`);
-    }
-  };
-  if (!spec) {
-    const type = header === null ? undefined : mediaType(header);
-    const reply = (data) => ({ status, type, data, response });
-    if (response.body === null)
-      return reply(undefined);
-    switch (type === undefined ? undefined : mediaKind(type)) {
-      case "json": {
-        const text = await response.text();
-        return reply(text === "" ? undefined : parse(text));
-      }
-      case "form":
-        return reply(await response.formData());
-      case "binary":
-        return reply(await response.blob());
-      default: {
-        const text = await response.text();
-        return reply(type === undefined && text === "" ? undefined : text);
-      }
-    }
-  }
-  const declared = spec[status];
-  if (!declared)
-    throw new UndeclaredStatusError(context, response);
-  const types = Object.keys(declared);
-  if (types.length === 0) {
-    return { status, type: undefined, data: undefined, response };
-  }
-  const type = header === null ? types.length === 1 ? types[0] : undefined : declaredType(declared, mediaType(header));
-  const media = type === undefined ? undefined : declared[type];
-  if (type === undefined || media === undefined) {
-    throw failure("invalid_content_type", `a ${status} reply is ${types.join(" or ")}, not ${header ?? "untyped"}`);
-  }
-  const reply = (data) => ({ status, type, data, response });
-  const settle = async (data) => {
-    if (!settings.validate || !media.schema)
-      return reply(data);
-    const result = await check(media.schema, data, "response");
-    if (!result.ok)
-      throw refused(result.issues);
-    return reply(settings.decode ? result.value : data);
-  };
-  switch (media.kind) {
-    case "json": {
-      const text = await response.text();
-      if (text === "" && !(settings.validate && media.schema)) {
-        return reply(undefined);
-      }
-      return settle(parse(text));
-    }
-    case "text":
-      return settle(await response.text());
-    case "form":
-      return reply(await response.formData());
-    default:
-      return reply(await response.blob());
-  }
-}
-
-// src/request/encode.ts
-var text = (value) => value instanceof Date ? value.toISOString() : String(value);
-var absent = (value) => value === undefined || value === null;
-function fillPath(context, param) {
-  return context.path.replace(/\{([^}]+)\}/g, (_, name) => {
-    const value = param?.[name];
-    if (absent(value)) {
-      throw new TypeError(`${context.method.toUpperCase()} ${context.path}: the path parameter ${name} is missing`);
-    }
-    return encodeURIComponent(text(value));
-  });
-}
-function writeQuery(query) {
-  if (query === undefined)
-    return "";
-  if (query instanceof URLSearchParams)
-    return query.toString();
-  const search = new URLSearchParams;
-  for (const [name, value] of Object.entries(query)) {
-    for (const item of Array.isArray(value) ? value : [value]) {
-      if (!absent(item))
-        search.append(name, text(item));
-    }
-  }
-  return search.toString();
-}
-function joinUrl(baseUrl, path, query) {
-  const root = baseUrl === undefined ? "" : String(baseUrl).replace(/\/+$/, "");
-  return `${root}${path}${query === "" ? "" : `?${query}`}`;
-}
-function writeBody(input, headers, own) {
-  const type = (fallback) => headers.set("content-type", own ?? fallback);
-  if (input.json !== undefined) {
-    type("application/json");
-    return JSON.stringify(input.json);
-  }
-  if (input.form !== undefined) {
-    headers.delete("content-type");
-    const { form } = input;
-    if (form instanceof FormData || form instanceof URLSearchParams) {
-      return form;
-    }
-    return [...fields(form)].some(([, value]) => value instanceof Blob) ? toFormData(form) : toSearchParams(form);
-  }
-  if (input.text !== undefined) {
-    type("text/plain");
-    return input.text;
-  }
-  if (input.body !== undefined) {
-    const { body } = input;
-    type(body instanceof Blob && body.type !== "" ? body.type : "application/octet-stream");
-    return body;
-  }
-  return;
-}
-function* fields(form) {
-  for (const [name, value] of Object.entries(form)) {
-    for (const item of Array.isArray(value) ? value : [value]) {
-      if (absent(item))
-        continue;
-      if (item instanceof Blob)
-        yield [name, item];
-      else if (typeof item === "object" && !(item instanceof Date)) {
-        yield [name, JSON.stringify(item)];
-      } else
-        yield [name, text(item)];
-    }
-  }
-}
-function toFormData(form) {
-  const data = new FormData;
-  for (const [name, value] of fields(form))
-    data.append(name, value);
-  return data;
-}
-function toSearchParams(form) {
-  const data = new URLSearchParams;
-  for (const [name, value] of fields(form)) {
-    if (value instanceof Blob) {
-      throw new TypeError(`${name} is a file: an application/x-www-form-urlencoded body cannot carry one`);
-    }
-    data.append(name, value);
-  }
-  return data;
-}
-
-// src/stream/connection.ts
-var failure = (context, status, issues) => new ValidationError(context, {
-  kind: "response",
-  ...context,
-  status,
-  issues
-});
-async function opened(settings, response, types) {
-  const { status } = response;
-  if (status === 204) {
-    await response.body?.cancel();
-    return false;
-  }
-  if (!response.ok)
-    throw new UndeclaredStatusError(settings.context, response);
-  const header = response.headers.get("content-type");
-  if (header === null || !types.includes(mediaType(header)) || !response.body) {
-    await response.body?.cancel();
-    throw failure(settings.context, status, [
-      {
-        target: "response",
-        path: [],
-        code: "invalid_content_type",
-        message: `a ${status} reply is ${types.join(" or ")}, not ${header ?? "untyped"}`
-      }
-    ]);
-  }
-  return true;
-}
-async function settle(settings, status, text, schema, what) {
-  let value;
-  try {
-    value = JSON.parse(text);
-  } catch {
-    throw failure(settings.context, status, [
-      {
-        target: "response",
-        path: [],
-        code: "invalid_json",
-        message: `${what} is not valid JSON`
-      }
-    ]);
-  }
-  if (!schema || !settings.validate)
-    return value;
-  const result = await check(schema, value, "response");
-  if (!result.ok)
-    throw failure(settings.context, status, result.issues);
-  return settings.decode ? result.value : value;
-}
-function pause(ms, ...signals) {
-  const live = signals.filter((each) => !!each);
-  return new Promise((resolve) => {
-    const done = () => {
-      clearTimeout(timer);
-      for (const each of live)
-        each.removeEventListener("abort", done);
-      resolve();
-    };
-    const timer = setTimeout(done, ms);
-    for (const each of live) {
-      if (each.aborted)
-        return done();
-      each.addEventListener("abort", done, { once: true });
-    }
-  });
-}
-
-class Reading {
-  #reader;
-  #signal;
-  #halt;
-  constructor(signal) {
-    this.closer = new AbortController;
-    this.#halt = () => {
-      this.#reader?.cancel().catch(() => {});
-    };
-    this.#signal = signal;
-    this.closer.signal.addEventListener("abort", this.#halt);
-    signal?.addEventListener("abort", this.#halt);
-  }
-  read(response) {
-    const body = response.body;
-    this.#reader = body.pipeThrough(new TextDecoderStream).getReader();
-    return this.#reader;
-  }
-  stopped() {
-    this.#signal?.throwIfAborted();
-    return this.closer.signal.aborted;
-  }
-  release() {
-    this.#reader?.cancel().catch(() => {});
-    this.#reader = undefined;
-    this.#signal?.removeEventListener("abort", this.#halt);
-  }
-  close() {
-    this.closer.abort();
-  }
-}
-
-// src/stream/sse-parser.ts
-var LINE_END = /\r\n|\r|\n/g;
-function createSseParser(lastEventId) {
-  let buffer = "";
-  let started = false;
-  let afterCr = false;
-  let data = "";
-  let type = "";
-  let id = lastEventId ?? "";
-  let dispatchedId = lastEventId;
-  let retry;
-  const dispatch = (events) => {
-    dispatchedId = id === "" ? undefined : id;
-    if (data === "") {
-      type = "";
-      return;
-    }
-    events.push({
-      event: type === "" ? "message" : type,
-      data: data.endsWith(`
-`) ? data.slice(0, -1) : data,
-      id: dispatchedId
-    });
-    data = "";
-    type = "";
-  };
-  const line = (text, events) => {
-    if (text === "")
-      return dispatch(events);
-    if (text.startsWith(":"))
-      return;
-    const colon = text.indexOf(":");
-    const field = colon === -1 ? text : text.slice(0, colon);
-    let value = colon === -1 ? "" : text.slice(colon + 1);
-    if (value.startsWith(" "))
-      value = value.slice(1);
-    switch (field) {
-      case "event":
-        type = value;
-        break;
-      case "data":
-        data += `${value}
-`;
-        break;
-      case "id":
-        if (!value.includes("\x00"))
-          id = value;
-        break;
-      case "retry":
-        if (/^\d+$/.test(value))
-          retry = Number(value);
-        break;
-    }
-  };
-  return {
-    push(chunk) {
-      let text = chunk;
-      if (!started && text !== "") {
-        started = true;
-        if (text.startsWith("\uFEFF"))
-          text = text.slice(1);
-      }
-      if (afterCr && text !== "") {
-        afterCr = false;
-        if (text.startsWith(`
-`))
-          text = text.slice(1);
-      }
-      buffer += text;
-      const events = [];
-      let start = 0;
-      LINE_END.lastIndex = 0;
-      for (let end = LINE_END.exec(buffer);end !== null; end = LINE_END.exec(buffer)) {
-        if (end[0] === "\r" && end.index === buffer.length - 1) {
-          afterCr = true;
-        }
-        line(buffer.slice(start, end.index), events);
-        start = end.index + end[0].length;
-      }
-      buffer = buffer.slice(start);
-      return events;
-    },
-    get retry() {
-      return retry;
-    },
-    get lastEventId() {
-      return dispatchedId;
-    }
-  };
-}
-
-// src/stream/event-stream.ts
-function eventStream(settings) {
-  const reading = new Reading(settings.signal);
-  let lastEventId = settings.lastEventId;
-  let delay = settings.reconnect ? settings.reconnect.delay : 0;
-  let started = false;
-  const declared = async (raw, status) => {
-    const { events } = settings;
-    if (!events)
-      return raw;
-    if (!Object.hasOwn(events, raw.event)) {
-      settings.onUnknownEvent?.(raw);
-      return;
-    }
-    const schema = events[raw.event];
-    if (!schema)
-      return raw;
-    const what = `the ${raw.event} event's data`;
-    const data = await settle(settings, status, raw.data, schema, what);
-    return { event: raw.event, data, id: raw.id };
-  };
-  const again = async (failures) => {
-    const { reconnect } = settings;
-    if (!reconnect || failures >= reconnect.attempts)
-      return false;
-    await pause(delay, reading.closer.signal, settings.signal);
-    return !reading.stopped();
-  };
-  async function* run() {
-    let failures = 0;
-    try {
-      for (;; ) {
-        let response;
-        try {
-          response = await settings.open(reading.closer.signal, lastEventId);
-        } catch (error) {
-          if (reading.closer.signal.aborted)
-            return;
-          if (error instanceof NetworkError && await again(failures++)) {
-            continue;
-          }
-          throw error;
-        }
-        if (!await opened(settings, response, ["text/event-stream"])) {
-          return;
-        }
-        const parser = createSseParser(lastEventId);
-        const reader = reading.read(response);
-        let dropped;
-        for (;; ) {
-          let chunk;
-          try {
-            chunk = await reader.read();
-          } catch (error) {
-            if (reading.stopped())
-              return;
-            dropped = error;
-            break;
-          }
-          if (reading.stopped())
-            return;
-          if (chunk.done)
-            break;
-          const events = parser.push(chunk.value);
-          lastEventId = parser.lastEventId;
-          delay = parser.retry ?? delay;
-          for (const raw of events) {
-            failures = 0;
-            const event = await declared(raw, response.status);
-            if (event !== undefined)
-              yield event;
-          }
-        }
-        if (!await again(failures++)) {
-          if (dropped === undefined)
-            return;
-          throw new NetworkError(settings.context, { cause: dropped });
-        }
-      }
-    } finally {
-      reading.release();
-    }
-  }
-  return {
-    [Symbol.asyncIterator]() {
-      if (started)
-        throw new TypeError("A stream is read once");
-      started = true;
-      return run();
-    },
-    close: () => reading.close(),
-    get lastEventId() {
-      return lastEventId;
-    }
-  };
-}
-
-// src/stream/line-parser.ts
-var RS = String.fromCharCode(30);
-function createLineParser() {
-  let buffer = "";
-  const records = (texts) => texts.map((text) => text.trim()).filter((text) => text !== "");
-  return {
-    push(chunk) {
-      const parts = (buffer + chunk).replaceAll(RS, `
-`).split(/\r?\n/);
-      buffer = parts.pop() ?? "";
-      return records(parts);
-    },
-    end() {
-      const rest = buffer;
-      buffer = "";
-      return records([rest]);
-    }
-  };
-}
-
-// src/stream/line-stream.ts
-var LINE_TYPES = [
-  "application/jsonl",
-  "application/x-ndjson",
-  "application/ndjson",
-  "application/jsonlines",
-  "application/x-jsonlines",
-  "application/json-seq"
-];
-function lineStream(settings) {
-  const reading = new Reading(settings.signal);
-  let started = false;
-  async function* run() {
-    try {
-      let response;
-      try {
-        response = await settings.open(reading.closer.signal, undefined);
-      } catch (error) {
-        if (reading.closer.signal.aborted)
-          return;
-        throw error;
-      }
-      if (!await opened(settings, response, LINE_TYPES))
-        return;
-      const parser = createLineParser();
-      const reader = reading.read(response);
-      for (;; ) {
-        let chunk;
-        try {
-          chunk = await reader.read();
-        } catch (error) {
-          if (reading.stopped())
-            return;
-          throw new NetworkError(settings.context, { cause: error });
-        }
-        if (reading.stopped())
-          return;
-        const texts = chunk.done ? parser.end() : parser.push(chunk.value);
-        for (const text of texts) {
-          yield await settle(settings, response.status, text, settings.item, "a line");
-        }
-        if (chunk.done)
-          return;
-      }
-    } finally {
-      reading.release();
-    }
-  }
-  return {
-    [Symbol.asyncIterator]() {
-      if (started)
-        throw new TypeError("A stream is read once");
-      started = true;
-      return run();
-    },
-    close: () => reading.close()
-  };
-}
-
-// src/client/create-http-client.ts
-var METHODS = [
-  "get",
-  "put",
-  "post",
-  "delete",
-  "options",
-  "head",
-  "patch",
-  "trace",
-  "query"
-];
-var RECONNECT_DELAY = 3000;
-var contextOf = (method, path, operationId) => operationId === undefined ? { method, path } : { method, path, operationId };
-function createHttpClient(options = {}) {
-  const signer = options.auth ? auth(options.auth) : undefined;
-  const claim = createLatest();
-  const latestSignal = (key) => key === undefined ? undefined : claim(key);
-  const sharedHeaders = async () => new Headers(typeof options.headers === "function" ? await options.headers() : options.headers);
-  const withDeadline = (timeout, signal) => {
-    const deadline = timeout === undefined ? undefined : AbortSignal.timeout(timeout);
-    const signals = [signal, deadline].filter((each) => each != null);
-    return {
-      deadline,
-      signal: signals.length > 1 ? AbortSignal.any(signals) : signals[0]
-    };
-  };
-  const dispatch = async (request, context, timeout, deadline, retry, added) => {
-    const fetch = options.fetch ?? ((sent) => globalThis.fetch(sent));
-    const send = async (sent) => {
-      try {
-        sent.signal.throwIfAborted();
-        return await fetch(sent);
-      } catch (error) {
-        if (request.signal.aborted)
-          throw error;
-        throw new NetworkError(context, { cause: error });
-      }
-    };
-    const again = retrySettings(retry);
-    const layers = [
-      ...again ? [retrying(again)] : [],
-      ...signer ? [signer] : [],
-      ...options.use ?? [],
-      ...added
-    ];
-    try {
-      return await compose(layers, send, context)(request);
-    } catch (error) {
-      if (deadline?.aborted && timeout !== undefined) {
-        throw new TimeoutError(context, timeout, { cause: error });
-      }
-      throw error;
-    }
-  };
-  const build = async (method, path, given, adjust) => {
-    const {
-      param,
-      query,
-      json,
-      form,
-      text,
-      body,
-      operationId,
-      timeout = options.timeout,
-      retry = options.retry,
-      headers: own,
-      signal,
-      ...rest
-    } = given;
-    const context = contextOf(method, path, operationId);
-    const headers = await sharedHeaders();
-    const callHeaders = new Headers(own);
-    callHeaders.forEach((value, name) => {
-      headers.set(name, value);
-    });
-    adjust?.(headers);
-    const url = joinUrl(options.baseUrl, fillPath(context, param), writeQuery(query));
-    const payload = writeBody({ json, form, text, body }, headers, callHeaders.get("content-type"));
-    const init = {
-      ...options.init,
-      ...rest,
-      method: method.toUpperCase(),
-      headers,
-      body: payload,
-      ...payload instanceof ReadableStream ? { duplex: "half" } : {}
-    };
-    return { context, url, init, timeout, retry, signal: signal ?? undefined };
-  };
-  const request = async (method, path, given, added) => {
-    const {
-      responses,
-      validate = true,
-      decode = true,
-      latest,
-      ...call
-    } = given;
-    const replaced = latestSignal(latest);
-    const built = await build(method, path, call);
-    const { deadline, signal } = withDeadline(built.timeout, joinSignals(built.signal, replaced));
-    const response = await dispatch(new Request(built.url, { ...built.init, signal }), built.context, built.timeout, deadline, built.retry, added);
-    return readReply(built.context, responses === undefined ? undefined : toSpec(responses), response, { validate, decode });
-  };
-  const opener = (method, path, call, accept, added) => async (stream, lastEventId) => {
-    const built = await build(method, path, call, (headers) => {
-      if (!headers.has("accept"))
-        headers.set("accept", accept);
-      if (lastEventId !== undefined) {
-        headers.set("last-event-id", lastEventId);
-      }
-    });
-    const deadline = new AbortController;
-    const clock = built.timeout === undefined ? undefined : setTimeout(() => deadline.abort(new DOMException("The stream did not open", "TimeoutError")), built.timeout);
-    const signals = [stream, deadline.signal];
-    if (built.signal)
-      signals.push(built.signal);
-    try {
-      return await dispatch(new Request(built.url, {
-        ...built.init,
-        signal: AbortSignal.any(signals)
-      }), built.context, built.timeout, deadline.signal, built.retry, added);
-    } finally {
-      clearTimeout(clock);
-    }
-  };
-  const events = (path, given, added) => {
-    const {
-      events,
-      onUnknownEvent,
-      reconnect,
-      lastEventId,
-      validate = true,
-      decode = true,
-      method = "get",
-      latest,
-      ...own
-    } = given;
-    const call = {
-      ...own,
-      signal: joinSignals(own.signal, latestSignal(latest))
-    };
-    const reconnects = reconnect === undefined ? method !== "post" && method !== "patch" : reconnect !== false;
-    const settings = typeof reconnect === "object" ? reconnect : {};
-    return eventStream({
-      context: contextOf(method, path, call.operationId),
-      open: opener(method, path, call, "text/event-stream", added),
-      signal: call.signal ?? undefined,
-      validate,
-      decode,
-      events,
-      onUnknownEvent,
-      reconnect: reconnects && {
-        attempts: settings.attempts ?? Number.POSITIVE_INFINITY,
-        delay: settings.delay ?? RECONNECT_DELAY
-      },
-      lastEventId
-    });
-  };
-  const lines = (path, given, added) => {
-    const {
-      item,
-      validate = true,
-      decode = true,
-      method = "get",
-      latest,
-      ...own
-    } = given;
-    const call = {
-      ...own,
-      signal: joinSignals(own.signal, latestSignal(latest))
-    };
-    return lineStream({
-      context: contextOf(method, path, call.operationId),
-      open: opener(method, path, call, LINE_TYPES.slice(0, 2).join(", "), added),
-      signal: call.signal ?? undefined,
-      validate,
-      decode,
-      item
-    });
-  };
-  const send = async (request, {
-    timeout = options.timeout,
-    retry = options.retry,
-    operationId,
-    latest
-  }, added) => {
-    const replaced = latestSignal(latest);
-    const method = request.method.toLowerCase();
-    const context = contextOf(method, new URL(request.url).pathname, operationId);
-    const headers = await sharedHeaders();
-    request.headers.forEach((value, name) => {
-      headers.set(name, value);
-    });
-    const { deadline, signal } = withDeadline(timeout, joinSignals(request.signal, replaced));
-    const sent = new Request(request, { headers, signal });
-    return dispatch(sent, context, timeout, deadline, retry, added);
-  };
-  const surface = (scope, inherited) => {
-    const own = [];
-    const layers = () => [...inherited(), ...own];
-    const scoped = (given) => {
-      const extra = scope();
-      const own = given ?? {};
-      return extra ? { ...own, signal: joinSignals(own.signal, extra) } : own;
-    };
-    const client = {
-      request: (method, path, given) => request(method, path, scoped(given), layers()),
-      send: (sent, given) => {
-        const extra = scope();
-        return send(extra ? new Request(sent, { signal: joinSignals(sent.signal, extra) }) : sent, given ?? {}, layers());
-      },
-      events: (path, given) => events(path, scoped(given), layers()),
-      lines: (path, given) => lines(path, scoped(given), layers()),
-      use: (...middlewares) => {
-        own.push(...middlewares);
-        return client;
-      },
-      group: () => {
-        let controller = new AbortController;
-        const group = surface(() => joinSignals(scope(), controller.signal), layers);
-        group.cancel = (reason) => {
-          controller.abort(reason ?? cancelled("The group was cancelled"));
-          controller = new AbortController;
-        };
-        Object.defineProperty(group, "signal", {
-          enumerable: true,
-          get: () => controller.signal
-        });
-        return group;
-      }
-    };
-    for (const method of METHODS) {
-      client[method] = (path, given) => request(method, path, scoped(given), layers());
-    }
-    return client;
-  };
-  return surface(() => {
-    return;
-  }, () => []);
-}
+import {
+  check2,
+  text2,
+  absent2,
+  fields2,
+  toFormData2,
+  toSearchParams2,
+  METHODS2
+} from "../chunks/index-52w12dh5.js";
 export {
-  METHODS,
-  absent,
-  check,
-  fields,
-  text,
-  toFormData,
-  toSearchParams
+  METHODS2 as METHODS,
+  absent2 as absent,
+  check2 as check,
+  fields2 as fields,
+  text2 as text,
+  toFormData2 as toFormData,
+  toSearchParams2 as toSearchParams
 };
 
-//# debugId=08EFC0FA159560DB64756E2164756E21
+//# debugId=A418B0FBE97D892D64756E2164756E21
 //# sourceMappingURL=index.js.map