@vobs/http 1.1.0 → 1.2.1

package/dist/index.cjs

@@ -0,0 +1,944 @@
+'use strict';
+
+var axios = require('axios');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// packages/reactivity/src/debug.ts
+var activeDebugHooks = null;
+function hasDebugHooks() {
+  return activeDebugHooks !== null;
+}
+__name(hasDebugHooks, "hasDebugHooks");
+function invokeDebug(name, ...args) {
+  return;
+}
+__name(invokeDebug, "invokeDebug");
+
+// packages/reactivity/src/scheduler.ts
+var _Scheduler = class _Scheduler {
+  constructor() {
+    this.dirtyEffects = /* @__PURE__ */ new Set();
+    this.lowPriorityEffects = /* @__PURE__ */ new Set();
+    // flush 不可重入（flushing 标志保证），缓冲数组可在轮次间安全复用，避免每轮分配。
+    this.normalBuffer = [];
+    this.lowBuffer = [];
+    this.flushing = false;
+    this.scheduled = false;
+    this.batchDepth = 0;
+  }
+  schedule(effect2) {
+    if (effect2.disposed) return;
+    this.dirtyEffects.add(effect2);
+    this.lowPriorityEffects.delete(effect2);
+    this.ensureScheduled();
+  }
+  /** Queue an effect behind normal updates while preserving deterministic order. */
+  scheduleLow(effect2) {
+    if (effect2.disposed) return;
+    if (!this.dirtyEffects.has(effect2)) this.lowPriorityEffects.add(effect2);
+    this.ensureScheduled();
+  }
+  ensureScheduled() {
+    if (this.batchDepth === 0 && !this.flushing && !this.scheduled) {
+      this.scheduled = true;
+      queueMicrotask(() => {
+        this.scheduled = false;
+        this.flush();
+      });
+    }
+  }
+  remove(effect2) {
+    this.dirtyEffects.delete(effect2);
+    this.lowPriorityEffects.delete(effect2);
+  }
+  batch(fn) {
+    this.batchDepth++;
+    try {
+      return fn();
+    } finally {
+      this.batchDepth--;
+      if (this.batchDepth === 0) this.flush();
+    }
+  }
+  flush() {
+    if (this.flushing || this.batchDepth > 0) return;
+    this.flushing = true;
+    let rounds = 0;
+    let firstError;
+    let hasError = false;
+    try {
+      while (this.dirtyEffects.size > 0 || this.lowPriorityEffects.size > 0) {
+        if (++rounds > 100) {
+          this.dirtyEffects.clear();
+          this.lowPriorityEffects.clear();
+          throw new Error("Vobs: \u54CD\u5E94\u5F0F\u66F4\u65B0\u8D85\u8FC7 100 \u8F6E\uFF0C\u53EF\u80FD\u5B58\u5728\u5FAA\u73AF\u4F9D\u8D56");
+        }
+        this.collectRunnable(this.dirtyEffects, this.normalBuffer);
+        this.collectRunnable(this.lowPriorityEffects, this.lowBuffer);
+        sortEffects(this.normalBuffer);
+        sortEffects(this.lowBuffer);
+        for (const effect2 of this.normalBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        for (const effect2 of this.lowBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        this.normalBuffer.length = 0;
+        this.lowBuffer.length = 0;
+      }
+    } finally {
+      this.normalBuffer.length = 0;
+      this.lowBuffer.length = 0;
+      this.flushing = false;
+    }
+    if (hasError) throw firstError;
+  }
+  /** 收集未 disposed 的 effect 并清空源集合；run() 期间新调度的 effect 留给下一轮。 */
+  collectRunnable(source, target) {
+    for (const effect2 of source) {
+      if (!effect2.disposed) target.push(effect2);
+    }
+    source.clear();
+  }
+};
+__name(_Scheduler, "Scheduler");
+function sortEffects(effects) {
+  if (effects.length > 1) {
+    effects.sort((a, b) => b.depth - a.depth || a.order - b.order);
+  }
+}
+__name(sortEffects, "sortEffects");
+
+// packages/runtime/src/debug.ts
+var activeRuntimeDebugContext = null;
+function getRuntimeDebugContext() {
+  return activeRuntimeDebugContext;
+}
+__name(getRuntimeDebugContext, "getRuntimeDebugContext");
+
+// packages/runtime/src/hmr.ts
+var globalTarget = globalThis;
+var hmrGlobal = globalTarget.__VOBS_HMR__ ?? { modules: /* @__PURE__ */ new Map() };
+globalTarget.__VOBS_HMR__ = hmrGlobal;
+
+// packages/vobs/src/app.ts
+function createInjectionKey(description) {
+  return Symbol(description);
+}
+__name(createInjectionKey, "createInjectionKey");
+
+// packages/http/src/stream.ts
+function createSSE(url, options = {}) {
+  const EventSourceImpl = options.eventSource ?? globalThis.EventSource;
+  if (!EventSourceImpl) throw new Error("HTTP: \u5F53\u524D\u73AF\u5883\u6CA1\u6709\u53EF\u7528\u7684 EventSource");
+  const source = new EventSourceImpl(url, { withCredentials: options.withCredentials ?? false });
+  if (options.onOpen) source.addEventListener("open", options.onOpen);
+  if (options.onMessage) source.addEventListener("message", options.onMessage);
+  if (options.onError) source.addEventListener("error", options.onError);
+  return {
+    source,
+    close: /* @__PURE__ */ __name(() => source.close(), "close")
+  };
+}
+__name(createSSE, "createSSE");
+function createWebSocket(url, options = {}) {
+  const WebSocketImpl = options.webSocket ?? globalThis.WebSocket;
+  if (!WebSocketImpl) throw new Error("HTTP: \u5F53\u524D\u73AF\u5883\u6CA1\u6709\u53EF\u7528\u7684 WebSocket");
+  const reconnectDelay = options.reconnectDelay ?? 1e3;
+  if (!Number.isFinite(reconnectDelay) || reconnectDelay < 0) {
+    throw new Error("HTTP: reconnectDelay \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6709\u9650\u6570\u5B57");
+  }
+  const listeners = /* @__PURE__ */ new Map();
+  let socket = null;
+  let state2 = "idle";
+  let manuallyClosed = false;
+  let reconnectTimer;
+  const client = {
+    get socket() {
+      return socket;
+    },
+    get state() {
+      return state2;
+    },
+    connect,
+    send(data) {
+      if (!socket || state2 !== "open") throw new Error("HTTP: WebSocket \u5C1A\u672A\u8FDE\u63A5");
+      socket.send(data);
+    },
+    close(code, reason) {
+      manuallyClosed = true;
+      if (reconnectTimer !== void 0) clearTimeout(reconnectTimer);
+      socket?.close(code, reason);
+      if (!socket) state2 = "closed";
+    },
+    on(event, listener) {
+      let eventListeners = listeners.get(event);
+      if (!eventListeners) {
+        eventListeners = /* @__PURE__ */ new Set();
+        listeners.set(event, eventListeners);
+      }
+      eventListeners.add(listener);
+      return () => eventListeners?.delete(listener);
+    }
+  };
+  connect();
+  return client;
+  function connect() {
+    if (state2 === "connecting" || state2 === "open") return;
+    manuallyClosed = false;
+    state2 = "connecting";
+    const protocols = options.protocols === void 0 ? void 0 : typeof options.protocols === "string" ? options.protocols : [...options.protocols];
+    socket = new WebSocketImpl(url, protocols);
+    socket.addEventListener("open", (event) => {
+      state2 = "open";
+      notify("open", event);
+    });
+    socket.addEventListener("message", (event) => notify("message", event));
+    socket.addEventListener("error", (event) => notify("error", event));
+    socket.addEventListener("close", (event) => {
+      state2 = "closed";
+      socket = null;
+      notify("close", event);
+      if (options.autoReconnect && !manuallyClosed) {
+        reconnectTimer = setTimeout(() => {
+          reconnectTimer = void 0;
+          connect();
+        }, reconnectDelay);
+      }
+    });
+  }
+  function notify(event, value) {
+    for (const listener of [...listeners.get(event) ?? []]) listener(value);
+  }
+}
+__name(createWebSocket, "createWebSocket");
+
+// packages/http/src/debug.ts
+var activeHTTPDebugHooks = null;
+var httpDebugListeners = /* @__PURE__ */ new Set();
+function setHTTPDebugHooks(hooks) {
+  const previous = activeHTTPDebugHooks;
+  activeHTTPDebugHooks = hooks;
+  return previous;
+}
+__name(setHTTPDebugHooks, "setHTTPDebugHooks");
+function getHTTPDebugHooks() {
+  return activeHTTPDebugHooks;
+}
+__name(getHTTPDebugHooks, "getHTTPDebugHooks");
+function subscribeHTTPDebug(listener) {
+  httpDebugListeners.add(listener);
+  return () => httpDebugListeners.delete(listener);
+}
+__name(subscribeHTTPDebug, "subscribeHTTPDebug");
+function emitHTTPDebug(event) {
+  try {
+    activeHTTPDebugHooks?.request?.(event);
+  } catch {
+  }
+  for (const listener of [...httpDebugListeners]) {
+    try {
+      listener(event);
+    } catch {
+    }
+  }
+}
+__name(emitHTTPDebug, "emitHTTPDebug");
+
+// packages/http/src/index.ts
+var PROGRESS_HANDLED = Symbol("vobs.http.progress-handled");
+var nextHTTPDebugId = 1;
+function toResourceFetcher(request) {
+  return (signal) => Promise.resolve().then(() => request(signal)).then((response) => response.data);
+}
+__name(toResourceFetcher, "toResourceFetcher");
+function createAxiosAdapter(request = builtInAxiosRequest) {
+  return async (config) => {
+    const { params: _params, ...requestConfig } = config;
+    const response = await request({ ...requestConfig, data: config.body });
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText ?? "",
+      headers: new Headers(response.headers),
+      config,
+      raw: response.raw ?? null
+    };
+  };
+}
+__name(createAxiosAdapter, "createAxiosAdapter");
+function createMockAdapter(handler) {
+  return async (config) => {
+    const result = await handler(config);
+    if (isResponse(result) || isHTTPResponse(result)) return result;
+    return {
+      data: result,
+      status: 200,
+      statusText: "OK",
+      headers: new Headers(),
+      config,
+      raw: null
+    };
+  };
+}
+__name(createMockAdapter, "createMockAdapter");
+function createXHRAdapter() {
+  return (config) => new Promise((resolve, reject) => {
+    if (typeof XMLHttpRequest === "undefined") {
+      reject(new Error("HTTP: \u5F53\u524D\u73AF\u5883\u6CA1\u6709\u53EF\u7528\u7684 XMLHttpRequest"));
+      return;
+    }
+    const xhr = new XMLHttpRequest();
+    xhr.open(config.method, config.url, true);
+    if (config.responseType === "arrayBuffer") xhr.responseType = "arraybuffer";
+    else if (config.responseType === "blob") xhr.responseType = "blob";
+    const signal = config.signal ?? config.state;
+    const abort = /* @__PURE__ */ __name(() => xhr.abort(), "abort");
+    if (signal?.aborted) {
+      reject(Object.assign(new Error("The operation was aborted"), { name: "AbortError" }));
+      return;
+    }
+    const cleanup = /* @__PURE__ */ __name(() => signal?.removeEventListener("abort", abort), "cleanup");
+    signal?.addEventListener("abort", abort, { once: true });
+    xhr.upload.onprogress = (event) => config.onUploadProgress?.(toProgress(event.loaded, event.lengthComputable ? event.total : void 0));
+    xhr.onprogress = (event) => config.onDownloadProgress?.(toProgress(event.loaded, event.lengthComputable ? event.total : void 0));
+    xhr.onload = () => {
+      cleanup();
+      const headers = new Headers();
+      xhr.getAllResponseHeaders().trim().split(/[\r\n]+/).forEach((line) => {
+        const separator = line.indexOf(":");
+        if (separator > 0) headers.set(line.slice(0, separator).trim(), line.slice(separator + 1).trim());
+      });
+      const body = config.responseType === "arrayBuffer" || config.responseType === "blob" ? xhr.response : xhr.responseText;
+      const response = new Response(body, {
+        status: xhr.status,
+        statusText: xhr.statusText,
+        headers
+      });
+      Object.defineProperty(response, PROGRESS_HANDLED, { value: true });
+      resolve(response);
+    };
+    xhr.onerror = () => {
+      cleanup();
+      reject(new Error("HTTP: XMLHttpRequest \u7F51\u7EDC\u9519\u8BEF"));
+    };
+    xhr.onabort = () => {
+      cleanup();
+      reject(Object.assign(new Error("The operation was aborted"), { name: "AbortError" }));
+    };
+    try {
+      const headers = new Headers(config.headers);
+      const body = encodeBody(config.body, headers, config.method);
+      headers.forEach((value, key) => xhr.setRequestHeader(key, value));
+      xhr.send(body ?? null);
+    } catch (error) {
+      cleanup();
+      reject(error);
+    }
+  });
+}
+__name(createXHRAdapter, "createXHRAdapter");
+function createFetchAdapter() {
+  return fetchAdapter;
+}
+__name(createFetchAdapter, "createFetchAdapter");
+var _HTTPError = class _HTTPError extends Error {
+  constructor(response) {
+    super(`HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`);
+    this.name = "HTTPError";
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.data = response.data;
+    this.config = response.config;
+    this.response = response;
+  }
+};
+__name(_HTTPError, "HTTPError");
+var HTTPError = _HTTPError;
+var _TimeoutError = class _TimeoutError extends Error {
+  constructor(timeout) {
+    super(`HTTP \u8BF7\u6C42\u8D85\u8FC7 ${timeout}ms \u672A\u5B8C\u6210`);
+    this.code = "ETIMEDOUT";
+    this.name = "TimeoutError";
+  }
+};
+__name(_TimeoutError, "TimeoutError");
+var TimeoutError = _TimeoutError;
+var HTTP_KEY = createInjectionKey("vobs.http");
+function createHTTPClient(options = {}) {
+  const defaults = normalizeClientOptions(options);
+  const requestInterceptors = createInterceptors();
+  const responseInterceptors = createInterceptors();
+  const adapter = options.adapter ?? createAxiosAdapter();
+  const limiter = createConcurrencyLimiter(options.concurrency ?? Infinity);
+  const pending = /* @__PURE__ */ new Map();
+  async function request(input) {
+    const initial = normalizeRequest(input, defaults);
+    const dedupeKey = getDedupeKey(initial, options.dedupe ?? false);
+    if (dedupeKey) {
+      const existing = pending.get(dedupeKey);
+      if (existing) return existing;
+      const shared = executeDebugRequest(initial);
+      pending.set(dedupeKey, shared);
+      void shared.finally(() => pending.delete(dedupeKey)).catch(() => void 0);
+      return shared;
+    }
+    return executeDebugRequest(initial);
+  }
+  __name(request, "request");
+  function executeDebugRequest(initial) {
+    const id = nextHTTPDebugId++;
+    const startedAt = Date.now();
+    const context = {
+      ...getRuntimeDebugContext(),
+      ...initial.debugContext
+    };
+    emitHTTPDebug({
+      id,
+      phase: "start",
+      status: "loading",
+      url: initial.url,
+      method: initial.method,
+      headers: debugHeaders(initial.headers),
+      requestBody: debugValue(initial.body),
+      startedAt,
+      attempt: 0,
+      retries: 0,
+      context: Object.keys(context).length > 0 ? context : void 0
+    });
+    return executeRequest(initial, id).then((response) => {
+      const endedAt = Date.now();
+      emitHTTPDebug({
+        id,
+        phase: "end",
+        status: "success",
+        url: response.config.url,
+        method: response.config.method,
+        headers: debugHeaders(response.config.headers),
+        requestBody: debugValue(response.config.body),
+        startedAt,
+        endedAt,
+        duration: endedAt - startedAt,
+        attempt: 0,
+        retries: 0,
+        responseStatus: response.status,
+        responseBody: debugValue(response.data),
+        context: Object.keys(context).length > 0 ? context : void 0
+      });
+      return response;
+    }, (error) => {
+      const endedAt = Date.now();
+      const cancelled = isAbortError(error);
+      emitHTTPDebug({
+        id,
+        phase: "end",
+        status: cancelled ? "cancelled" : "error",
+        url: initial.url,
+        method: initial.method,
+        headers: debugHeaders(initial.headers),
+        requestBody: debugValue(initial.body),
+        startedAt,
+        endedAt,
+        duration: endedAt - startedAt,
+        attempt: 0,
+        retries: 0,
+        responseStatus: error instanceof HTTPError ? error.status : void 0,
+        responseBody: error instanceof HTTPError ? debugValue(error.data) : void 0,
+        error: { name: error instanceof Error ? error.name : "Error", message: error instanceof Error ? error.message : String(error) },
+        context: Object.keys(context).length > 0 ? context : void 0
+      });
+      throw error;
+    });
+  }
+  __name(executeDebugRequest, "executeDebugRequest");
+  async function executeRequest(initial, debugId) {
+    const requestChain = requestInterceptors.handlers();
+    const responseChain = responseInterceptors.handlers().reverse();
+    let chain = Promise.resolve(initial);
+    for (const handler of requestChain) {
+      chain = chain.then(handler.onFulfilled, handler.onRejected);
+    }
+    chain = chain.then((config) => limiter(() => executeWithRetry(config, adapter, debugId)));
+    for (const handler of responseChain) {
+      chain = chain.then(handler.onFulfilled, handler.onRejected);
+    }
+    return chain;
+  }
+  __name(executeRequest, "executeRequest");
+  function method(methodName, url, input = {}) {
+    return request({ ...input, url, method: methodName });
+  }
+  __name(method, "method");
+  function methodWithBody(methodName, url, body, input = {}) {
+    return request({ ...input, url, method: methodName, body });
+  }
+  __name(methodWithBody, "methodWithBody");
+  const client = {
+    interceptors: {
+      request: requestInterceptors,
+      response: responseInterceptors
+    },
+    request,
+    get: /* @__PURE__ */ __name((url, input) => method("GET", url, input), "get"),
+    delete: /* @__PURE__ */ __name((url, input) => method("DELETE", url, input), "delete"),
+    head: /* @__PURE__ */ __name((url, input) => method("HEAD", url, input), "head"),
+    post: /* @__PURE__ */ __name((url, body, input) => methodWithBody("POST", url, body, input), "post"),
+    put: /* @__PURE__ */ __name((url, body, input) => methodWithBody("PUT", url, body, input), "put"),
+    patch: /* @__PURE__ */ __name((url, body, input) => methodWithBody("PATCH", url, body, input), "patch")
+  };
+  return client;
+  async function executeWithRetry(config, requestAdapter, debugId) {
+    const controller = new AbortController();
+    const inputSignal = config.signal ?? config.state;
+    let timedOut = false;
+    let timeoutId;
+    const abortFromInput = /* @__PURE__ */ __name(() => controller.abort(inputSignal?.reason), "abortFromInput");
+    if (inputSignal) {
+      if (inputSignal.aborted) controller.abort(inputSignal.reason);
+      else inputSignal.addEventListener("abort", abortFromInput, { once: true });
+    }
+    if (config.timeout !== void 0 && config.timeout > 0) {
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, config.timeout);
+    }
+    const adapterConfig = { ...config, signal: controller.signal };
+    let attempt = 0;
+    try {
+      while (true) {
+        try {
+          const result = await requestAdapter(adapterConfig);
+          const response = isHTTPResponse(result) ? result : await parseResponse(result, adapterConfig);
+          if (response.status < 200 || response.status >= 300) throw new HTTPError(response);
+          return response;
+        } catch (error) {
+          if (timedOut) throw new TimeoutError(config.timeout);
+          if (inputSignal?.aborted || isAbortError(error)) throw error;
+          const nextAttempt = attempt + 1;
+          if (nextAttempt > (config.retry ?? 0)) throw toError(error);
+          const shouldRetry = config.shouldRetry ? await config.shouldRetry(toError(error), nextAttempt) : isRetryable(error);
+          if (!shouldRetry) throw toError(error);
+          attempt = nextAttempt;
+          const retryContext = {
+            ...getRuntimeDebugContext(),
+            ...config.debugContext
+          };
+          emitHTTPDebug({
+            id: debugId ?? 0,
+            phase: "retry",
+            status: "retrying",
+            url: config.url,
+            method: config.method,
+            headers: debugHeaders(config.headers),
+            requestBody: debugValue(config.body),
+            startedAt: Date.now(),
+            attempt,
+            retries: attempt,
+            error: { name: toError(error).name, message: toError(error).message },
+            context: Object.keys(retryContext).length > 0 ? retryContext : void 0
+          });
+          const delay = resolveRetryDelay(config.retryDelay ?? 0, attempt, toError(error));
+          if (delay > 0) await wait(delay);
+        }
+      }
+    } finally {
+      if (timeoutId !== void 0) clearTimeout(timeoutId);
+      inputSignal?.removeEventListener("abort", abortFromInput);
+    }
+  }
+}
+__name(createHTTPClient, "createHTTPClient");
+function debugHeaders(headers) {
+  const safe = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (/authorization|cookie|token|password|secret|api[-_]?key/i.test(key)) continue;
+    safe[key] = value;
+  }
+  return safe;
+}
+__name(debugHeaders, "debugHeaders");
+function debugValue(value, depth = 0) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+  if (value === void 0) return void 0;
+  if (depth >= 2) return "[MaxDepth]";
+  if (typeof value === "bigint") return `${value}n`;
+  if (typeof value === "function") return `[Function ${value.name || "anonymous"}]`;
+  if (typeof value !== "object") return String(value);
+  if (Array.isArray(value)) return value.slice(0, 20).map((item) => debugValue(item, depth + 1));
+  try {
+    return Object.fromEntries(Object.entries(value).slice(0, 30).map(([key, item]) => [key, debugValue(item, depth + 1)]));
+  } catch {
+    return "[Uninspectable]";
+  }
+}
+__name(debugValue, "debugValue");
+function httpPlugin(options = {}) {
+  return {
+    name: "@vobs/http",
+    version: "0.1.0",
+    install(context) {
+      const client = options.client ?? createHTTPClient(options);
+      context.provide(HTTP_KEY, client);
+    }
+  };
+}
+__name(httpPlugin, "httpPlugin");
+function createInterceptors() {
+  const entries = [];
+  return {
+    use(onFulfilled, onRejected) {
+      entries.push({
+        onFulfilled: /* @__PURE__ */ __name((value) => onFulfilled ? onFulfilled(value) : value, "onFulfilled"),
+        onRejected: /* @__PURE__ */ __name((error) => onRejected ? onRejected(error) : Promise.reject(error), "onRejected")
+      });
+      return entries.length - 1;
+    },
+    eject(id) {
+      if (id >= 0 && id < entries.length) entries[id] = null;
+    },
+    clear() {
+      entries.fill(null);
+    },
+    handlers() {
+      return entries.filter((entry) => entry !== null);
+    }
+  };
+}
+__name(createInterceptors, "createInterceptors");
+function normalizeClientOptions(options) {
+  return {
+    baseURL: options.baseURL ?? "",
+    headers: options.headers ?? {},
+    timeout: validateTimeout(options.timeout ?? 0),
+    retry: validateRetry(options.retry ?? 0),
+    retryDelay: options.retryDelay ?? 0,
+    shouldRetry: options.shouldRetry
+  };
+}
+__name(normalizeClientOptions, "normalizeClientOptions");
+function createConcurrencyLimiter(limit) {
+  if (limit !== Infinity && (!Number.isFinite(limit) || limit < 1 || !Number.isInteger(limit))) {
+    throw new Error("HTTP: concurrency \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 1 \u7684\u6574\u6570");
+  }
+  let active = 0;
+  const queue = [];
+  return (task) => new Promise((resolve, reject) => {
+    const run = /* @__PURE__ */ __name(() => {
+      active++;
+      Promise.resolve().then(task).then(resolve, reject).finally(() => {
+        active--;
+        queue.shift()?.();
+      });
+    }, "run");
+    if (active < limit) run();
+    else queue.push(run);
+  });
+}
+__name(createConcurrencyLimiter, "createConcurrencyLimiter");
+function getDedupeKey(config, defaultEnabled) {
+  if (config.dedupe === false) return void 0;
+  if (config.dedupeKey) return config.dedupeKey;
+  if (!(config.dedupe ?? defaultEnabled)) return void 0;
+  if (config.method !== "GET" && config.method !== "HEAD") return void 0;
+  return `${config.method} ${config.url}`;
+}
+__name(getDedupeKey, "getDedupeKey");
+function normalizeRequest(input, defaults) {
+  if (!input.url) throw new Error("HTTP: url \u4E0D\u80FD\u4E3A\u7A7A");
+  const method = (input.method ?? "GET").toUpperCase();
+  const timeout = validateTimeout(input.timeout ?? defaults.timeout);
+  const retry = validateRetry(input.retry ?? defaults.retry);
+  const retryDelay = input.retryDelay ?? defaults.retryDelay;
+  const signal = input.signal ?? input.state;
+  if (input.signal && input.state && input.signal !== input.state) {
+    throw new Error("HTTP: signal \u548C state \u4E0D\u80FD\u540C\u65F6\u6307\u5411\u4E0D\u540C\u7684 AbortSignal");
+  }
+  return {
+    ...input,
+    url: appendParams(resolveURL(input.url, input.baseURL ?? defaults.baseURL), input.params),
+    method,
+    headers: toHeaders(defaults.headers, input.headers),
+    timeout,
+    retry,
+    retryDelay,
+    shouldRetry: input.shouldRetry ?? defaults.shouldRetry,
+    signal
+  };
+}
+__name(normalizeRequest, "normalizeRequest");
+async function fetchAdapter(config) {
+  if (typeof fetch !== "function") throw new Error("HTTP: \u5F53\u524D\u73AF\u5883\u6CA1\u6709\u53EF\u7528\u7684 fetch");
+  const headers = new Headers(config.headers);
+  const body = encodeBody(config.body, headers, config.method);
+  return fetch(config.url, {
+    method: config.method,
+    headers,
+    body,
+    signal: config.signal,
+    cache: config.cache,
+    credentials: config.credentials,
+    mode: config.mode
+  });
+}
+__name(fetchAdapter, "fetchAdapter");
+async function parseResponse(response, config) {
+  const data = config.responseType === "response" ? response : await parseBody(response, config.responseType, hasHandledProgress(response) ? void 0 : config.onDownloadProgress);
+  return {
+    data,
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+    config,
+    raw: response
+  };
+}
+__name(parseResponse, "parseResponse");
+var builtInAxiosRequest = /* @__PURE__ */ __name(async (config) => {
+  const responseType = config.responseType === "response" ? "arraybuffer" : toAxiosResponseType(config.responseType);
+  const response = await axios__default.default.request({
+    url: config.url,
+    method: config.method,
+    headers: config.headers,
+    data: config.method === "GET" || config.method === "HEAD" ? void 0 : config.body,
+    signal: config.signal,
+    timeout: config.timeout,
+    responseType,
+    withCredentials: toAxiosCredentials(config.credentials),
+    validateStatus: /* @__PURE__ */ __name(() => true, "validateStatus"),
+    adapter: "fetch",
+    fetchOptions: compactFetchOptions(config),
+    onUploadProgress: /* @__PURE__ */ __name((event) => config.onUploadProgress?.(toAxiosProgress(event.loaded, event.total)), "onUploadProgress"),
+    onDownloadProgress: /* @__PURE__ */ __name((event) => config.onDownloadProgress?.(toAxiosProgress(event.loaded, event.total)), "onDownloadProgress")
+  });
+  const raw = config.responseType === "response" ? toRawResponse(response.data, response.status, response.statusText, response.headers) : null;
+  return {
+    data: raw ?? response.data,
+    status: response.status,
+    statusText: response.statusText,
+    headers: typeof response.headers?.toJSON === "function" ? response.headers.toJSON() : response.headers,
+    raw
+  };
+}, "builtInAxiosRequest");
+function toAxiosCredentials(credentials) {
+  if (credentials === "include") return true;
+  if (credentials === "omit") return false;
+  return void 0;
+}
+__name(toAxiosCredentials, "toAxiosCredentials");
+function toRawResponse(data, status, statusText, headers) {
+  if (typeof Response === "undefined") throw new Error("HTTP: \u5F53\u524D\u73AF\u5883\u6CA1\u6709\u53EF\u7528\u7684 Response");
+  const body = status === 204 || status === 205 ? null : data;
+  return new Response(body, {
+    status,
+    statusText: statusText ?? "",
+    headers: new Headers(headers)
+  });
+}
+__name(toRawResponse, "toRawResponse");
+function toAxiosResponseType(responseType) {
+  if (responseType === "arrayBuffer") return "arraybuffer";
+  if (responseType === "response") return void 0;
+  return responseType;
+}
+__name(toAxiosResponseType, "toAxiosResponseType");
+function compactFetchOptions(config) {
+  const options = {
+    cache: config.cache,
+    credentials: config.credentials,
+    mode: config.mode
+  };
+  const entries = Object.entries(options).filter(([, value]) => value !== void 0);
+  return entries.length === 0 ? void 0 : Object.fromEntries(entries);
+}
+__name(compactFetchOptions, "compactFetchOptions");
+function toAxiosProgress(loaded, total) {
+  return {
+    loaded,
+    total,
+    percent: total && total > 0 ? loaded / total * 100 : void 0
+  };
+}
+__name(toAxiosProgress, "toAxiosProgress");
+async function parseBody(response, responseType, onDownloadProgress) {
+  if (response.status === 204 || response.status === 205) return null;
+  const bytes = onDownloadProgress && response.body ? await readResponseBytes(response, onDownloadProgress) : void 0;
+  if (responseType === "blob") return bytes ? new Blob([bytes]) : response.blob();
+  if (responseType === "arrayBuffer") return bytes ? bytes.buffer : response.arrayBuffer();
+  const text = bytes ? new TextDecoder().decode(bytes) : await response.text();
+  if (responseType === "text") return text;
+  if (!text) return null;
+  if (responseType === "json" || response.headers.get("content-type")?.includes("json")) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new Error("HTTP: \u54CD\u5E94\u4E0D\u662F\u6709\u6548 JSON");
+    }
+  }
+  return text;
+}
+__name(parseBody, "parseBody");
+async function readResponseBytes(response, onProgress) {
+  const reader = response.body.getReader();
+  const chunks = [];
+  const totalHeader = response.headers.get("content-length");
+  const parsedTotal = totalHeader ? Number(totalHeader) : NaN;
+  const total = Number.isFinite(parsedTotal) && parsedTotal >= 0 ? parsedTotal : void 0;
+  let loaded = 0;
+  while (true) {
+    const next = await reader.read();
+    if (next.done) break;
+    chunks.push(next.value);
+    loaded += next.value.byteLength;
+    onProgress(toProgress(loaded, total));
+  }
+  const result = new Uint8Array(loaded);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+__name(readResponseBytes, "readResponseBytes");
+function isHTTPResponse(value) {
+  return typeof value === "object" && value !== null && "data" in value && "status" in value && "config" in value;
+}
+__name(isHTTPResponse, "isHTTPResponse");
+function isResponse(value) {
+  return typeof Response !== "undefined" && value instanceof Response;
+}
+__name(isResponse, "isResponse");
+function hasHandledProgress(response) {
+  return Boolean(response[PROGRESS_HANDLED]);
+}
+__name(hasHandledProgress, "hasHandledProgress");
+function encodeBody(body, headers, method) {
+  if (body === void 0 || body === null || method === "GET" || method === "HEAD") return void 0;
+  if (typeof body === "string" || body instanceof Blob || body instanceof FormData || body instanceof ArrayBuffer || body instanceof URLSearchParams) return body;
+  if (!headers.has("content-type")) headers.set("content-type", "application/json");
+  return JSON.stringify(body);
+}
+__name(encodeBody, "encodeBody");
+function toHeaders(...inputs) {
+  const headers = new Headers();
+  for (const input of inputs) {
+    if (!input) continue;
+    new Headers(input).forEach((value, key) => headers.set(key, value));
+  }
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+__name(toHeaders, "toHeaders");
+function resolveURL(url, baseURL) {
+  if (!baseURL || /^[a-z][a-z\d+.-]*:/i.test(url) || url.startsWith("//")) return url;
+  if (!baseURL) return url;
+  return `${baseURL.replace(/\/$/, "")}/${url.replace(/^\//, "")}`;
+}
+__name(resolveURL, "resolveURL");
+function appendParams(url, params) {
+  if (!params) return url;
+  const query = params instanceof URLSearchParams ? params : toSearchParams(params);
+  const serialized = query.toString();
+  if (!serialized) return url;
+  return `${url}${url.includes("?") ? "&" : "?"}${serialized}`;
+}
+__name(appendParams, "appendParams");
+function toSearchParams(params) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) search.append(key, String(item));
+    } else if (typeof value === "object") {
+      search.set(key, JSON.stringify(value));
+    } else {
+      search.set(key, String(value));
+    }
+  }
+  return search;
+}
+__name(toSearchParams, "toSearchParams");
+function isRetryable(error) {
+  return error instanceof HTTPError ? error.status === 429 || error.status >= 500 : !isAbortError(error);
+}
+__name(isRetryable, "isRetryable");
+function isAbortError(error) {
+  return Boolean(error) && typeof error === "object" && (error.name === "AbortError" || error.code === "ERR_CANCELED");
+}
+__name(isAbortError, "isAbortError");
+function resolveRetryDelay(retryDelay, attempt, error) {
+  const delay = typeof retryDelay === "function" ? retryDelay(attempt, error) : retryDelay;
+  if (!Number.isFinite(delay) || delay < 0) throw new Error("HTTP: retryDelay \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6709\u9650\u6570\u5B57");
+  return delay;
+}
+__name(resolveRetryDelay, "resolveRetryDelay");
+function validateRetry(retry) {
+  if (!Number.isInteger(retry) || retry < 0) throw new Error("HTTP: retry \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6574\u6570");
+  return retry;
+}
+__name(validateRetry, "validateRetry");
+function validateTimeout(timeout) {
+  if (!Number.isFinite(timeout) || timeout < 0) throw new Error("HTTP: timeout \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6709\u9650\u6570\u5B57");
+  return timeout;
+}
+__name(validateTimeout, "validateTimeout");
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+__name(toError, "toError");
+function wait(delay) {
+  return new Promise((resolve) => setTimeout(resolve, delay));
+}
+__name(wait, "wait");
+function toProgress(loaded, total) {
+  return {
+    loaded,
+    total,
+    percent: total && total > 0 ? loaded / total * 100 : void 0
+  };
+}
+__name(toProgress, "toProgress");
+
+exports.HTTPError = HTTPError;
+exports.HTTP_KEY = HTTP_KEY;
+exports.TimeoutError = TimeoutError;
+exports.createAxiosAdapter = createAxiosAdapter;
+exports.createConcurrencyLimiter = createConcurrencyLimiter;
+exports.createFetchAdapter = createFetchAdapter;
+exports.createHTTPClient = createHTTPClient;
+exports.createMockAdapter = createMockAdapter;
+exports.createSSE = createSSE;
+exports.createWebSocket = createWebSocket;
+exports.createXHRAdapter = createXHRAdapter;
+exports.emitHTTPDebug = emitHTTPDebug;
+exports.getHTTPDebugHooks = getHTTPDebugHooks;
+exports.httpPlugin = httpPlugin;
+exports.setHTTPDebugHooks = setHTTPDebugHooks;
+exports.subscribeHTTPDebug = subscribeHTTPDebug;
+exports.toResourceFetcher = toResourceFetcher;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map