zupost 0.0.0

package/dist/index.js

@@ -0,0 +1,744 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Zupost: () => Zupost
+});
+module.exports = __toCommonJS(index_exports);
+
+// package.json
+var version = "0.0.0";
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/errors/HTTPError.js
+var HTTPError = class extends Error {
+  constructor(response, request, options) {
+    var _a;
+    const code = response.status || response.status === 0 ? response.status : "";
+    const title = (_a = response.statusText) != null ? _a : "";
+    const status = `${code} ${title}`.trim();
+    const reason = status ? `status code ${status}` : "an unknown error";
+    super(`Request failed with ${reason}: ${request.method} ${request.url}`);
+    __publicField(this, "response");
+    __publicField(this, "request");
+    __publicField(this, "options");
+    this.name = "HTTPError";
+    this.response = response;
+    this.request = request;
+    this.options = options;
+  }
+};
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/errors/TimeoutError.js
+var TimeoutError = class extends Error {
+  constructor(request) {
+    super(`Request timed out: ${request.method} ${request.url}`);
+    __publicField(this, "request");
+    this.name = "TimeoutError";
+    this.request = request;
+  }
+};
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/core/constants.js
+var supportsRequestStreams = (() => {
+  let duplexAccessed = false;
+  let hasContentType = false;
+  const supportsReadableStream = typeof globalThis.ReadableStream === "function";
+  const supportsRequest = typeof globalThis.Request === "function";
+  if (supportsReadableStream && supportsRequest) {
+    try {
+      hasContentType = new globalThis.Request("https://empty.invalid", {
+        body: new globalThis.ReadableStream(),
+        method: "POST",
+        // @ts-expect-error - Types are outdated.
+        get duplex() {
+          duplexAccessed = true;
+          return "half";
+        }
+      }).headers.has("Content-Type");
+    } catch (error) {
+      if (error instanceof Error && error.message === "unsupported BodyInit type") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  return duplexAccessed && !hasContentType;
+})();
+var supportsAbortController = typeof globalThis.AbortController === "function";
+var supportsAbortSignal = typeof globalThis.AbortSignal === "function" && typeof globalThis.AbortSignal.any === "function";
+var supportsResponseStreams = typeof globalThis.ReadableStream === "function";
+var supportsFormData = typeof globalThis.FormData === "function";
+var requestMethods = ["get", "post", "put", "patch", "head", "delete"];
+var validate = () => void 0;
+validate();
+var responseTypes = {
+  json: "application/json",
+  text: "text/*",
+  formData: "multipart/form-data",
+  arrayBuffer: "*/*",
+  blob: "*/*",
+  // Supported in modern Fetch implementations (for example, browsers and recent Node.js/undici).
+  // We still feature-check at runtime before exposing the shortcut.
+  bytes: "*/*"
+};
+var maxSafeTimeout = 2147483647;
+var usualFormBoundarySize = new TextEncoder().encode("------WebKitFormBoundaryaxpyiPgbbPti10Rw").length;
+var stop = Symbol("stop");
+var kyOptionKeys = {
+  json: true,
+  parseJson: true,
+  stringifyJson: true,
+  searchParams: true,
+  prefixUrl: true,
+  retry: true,
+  timeout: true,
+  hooks: true,
+  throwHttpErrors: true,
+  onDownloadProgress: true,
+  onUploadProgress: true,
+  fetch: true
+};
+var requestOptionsRegistry = {
+  method: true,
+  headers: true,
+  body: true,
+  mode: true,
+  credentials: true,
+  cache: true,
+  redirect: true,
+  referrer: true,
+  referrerPolicy: true,
+  integrity: true,
+  keepalive: true,
+  signal: true,
+  window: true,
+  dispatcher: true,
+  duplex: true,
+  priority: true
+};
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/body.js
+var getBodySize = (body) => {
+  if (!body) {
+    return 0;
+  }
+  if (body instanceof FormData) {
+    let size = 0;
+    for (const [key, value] of body) {
+      size += usualFormBoundarySize;
+      size += new TextEncoder().encode(`Content-Disposition: form-data; name="${key}"`).length;
+      size += typeof value === "string" ? new TextEncoder().encode(value).length : value.size;
+    }
+    return size;
+  }
+  if (body instanceof Blob) {
+    return body.size;
+  }
+  if (body instanceof ArrayBuffer) {
+    return body.byteLength;
+  }
+  if (typeof body === "string") {
+    return new TextEncoder().encode(body).length;
+  }
+  if (body instanceof URLSearchParams) {
+    return new TextEncoder().encode(body.toString()).length;
+  }
+  if ("byteLength" in body) {
+    return body.byteLength;
+  }
+  if (typeof body === "object" && body !== null) {
+    try {
+      const jsonString = JSON.stringify(body);
+      return new TextEncoder().encode(jsonString).length;
+    } catch (e) {
+      return 0;
+    }
+  }
+  return 0;
+};
+var withProgress = (stream, totalBytes, onProgress) => {
+  let previousChunk;
+  let transferredBytes = 0;
+  return stream.pipeThrough(new TransformStream({
+    transform(currentChunk, controller) {
+      controller.enqueue(currentChunk);
+      if (previousChunk) {
+        transferredBytes += previousChunk.byteLength;
+        let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+        if (percent >= 1) {
+          percent = 1 - Number.EPSILON;
+        }
+        onProgress == null ? void 0 : onProgress({ percent, totalBytes: Math.max(totalBytes, transferredBytes), transferredBytes }, previousChunk);
+      }
+      previousChunk = currentChunk;
+    },
+    flush() {
+      if (previousChunk) {
+        transferredBytes += previousChunk.byteLength;
+        onProgress == null ? void 0 : onProgress({ percent: 1, totalBytes: Math.max(totalBytes, transferredBytes), transferredBytes }, previousChunk);
+      }
+    }
+  }));
+};
+var streamResponse = (response, onDownloadProgress) => {
+  if (!response.body) {
+    return response;
+  }
+  if (response.status === 204) {
+    return new Response(null, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  const totalBytes = Number(response.headers.get("content-length")) || 0;
+  return new Response(withProgress(response.body, totalBytes, onDownloadProgress), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+};
+var streamRequest = (request, onUploadProgress, originalBody) => {
+  if (!request.body) {
+    return request;
+  }
+  const totalBytes = getBodySize(originalBody != null ? originalBody : request.body);
+  return new Request(request, {
+    // @ts-expect-error - Types are outdated.
+    duplex: "half",
+    body: withProgress(request.body, totalBytes, onUploadProgress)
+  });
+};
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/is.js
+var isObject = (value) => value !== null && typeof value === "object";
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/merge.js
+var validateAndMerge = (...sources) => {
+  for (const source of sources) {
+    if ((!isObject(source) || Array.isArray(source)) && source !== void 0) {
+      throw new TypeError("The `options` argument must be an object");
+    }
+  }
+  return deepMerge({}, ...sources);
+};
+var mergeHeaders = (source1 = {}, source2 = {}) => {
+  const result = new globalThis.Headers(source1);
+  const isHeadersInstance = source2 instanceof globalThis.Headers;
+  const source = new globalThis.Headers(source2);
+  for (const [key, value] of source.entries()) {
+    if (isHeadersInstance && value === "undefined" || value === void 0) {
+      result.delete(key);
+    } else {
+      result.set(key, value);
+    }
+  }
+  return result;
+};
+function newHookValue(original, incoming, property) {
+  var _a, _b;
+  return Object.hasOwn(incoming, property) && incoming[property] === void 0 ? [] : deepMerge((_a = original[property]) != null ? _a : [], (_b = incoming[property]) != null ? _b : []);
+}
+var mergeHooks = (original = {}, incoming = {}) => ({
+  beforeRequest: newHookValue(original, incoming, "beforeRequest"),
+  beforeRetry: newHookValue(original, incoming, "beforeRetry"),
+  afterResponse: newHookValue(original, incoming, "afterResponse"),
+  beforeError: newHookValue(original, incoming, "beforeError")
+});
+var deepMerge = (...sources) => {
+  let returnValue = {};
+  let headers = {};
+  let hooks = {};
+  for (const source of sources) {
+    if (Array.isArray(source)) {
+      if (!Array.isArray(returnValue)) {
+        returnValue = [];
+      }
+      returnValue = [...returnValue, ...source];
+    } else if (isObject(source)) {
+      for (let [key, value] of Object.entries(source)) {
+        if (isObject(value) && key in returnValue) {
+          value = deepMerge(returnValue[key], value);
+        }
+        returnValue = __spreadProps(__spreadValues({}, returnValue), { [key]: value });
+      }
+      if (isObject(source.hooks)) {
+        hooks = mergeHooks(hooks, source.hooks);
+        returnValue.hooks = hooks;
+      }
+      if (isObject(source.headers)) {
+        headers = mergeHeaders(headers, source.headers);
+        returnValue.headers = headers;
+      }
+    }
+  }
+  return returnValue;
+};
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/normalize.js
+var normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
+var retryMethods = ["get", "put", "head", "delete", "options", "trace"];
+var retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
+var retryAfterStatusCodes = [413, 429, 503];
+var defaultRetryOptions = {
+  limit: 2,
+  methods: retryMethods,
+  statusCodes: retryStatusCodes,
+  afterStatusCodes: retryAfterStatusCodes,
+  maxRetryAfter: Number.POSITIVE_INFINITY,
+  backoffLimit: Number.POSITIVE_INFINITY,
+  delay: (attemptCount) => 0.3 * __pow(2, attemptCount - 1) * 1e3
+};
+var normalizeRetryOptions = (retry = {}) => {
+  if (typeof retry === "number") {
+    return __spreadProps(__spreadValues({}, defaultRetryOptions), {
+      limit: retry
+    });
+  }
+  if (retry.methods && !Array.isArray(retry.methods)) {
+    throw new Error("retry.methods must be an array");
+  }
+  if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
+    throw new Error("retry.statusCodes must be an array");
+  }
+  return __spreadValues(__spreadValues({}, defaultRetryOptions), retry);
+};
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/timeout.js
+function timeout(request, init, abortController, options) {
+  return __async(this, null, function* () {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        if (abortController) {
+          abortController.abort();
+        }
+        reject(new TimeoutError(request));
+      }, options.timeout);
+      void options.fetch(request, init).then(resolve).catch(reject).then(() => {
+        clearTimeout(timeoutId);
+      });
+    });
+  });
+}
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/delay.js
+function delay(_0, _1) {
+  return __async(this, arguments, function* (ms, { signal }) {
+    return new Promise((resolve, reject) => {
+      if (signal) {
+        signal.throwIfAborted();
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
+      function abortHandler() {
+        clearTimeout(timeoutId);
+        reject(signal.reason);
+      }
+      const timeoutId = setTimeout(() => {
+        signal == null ? void 0 : signal.removeEventListener("abort", abortHandler);
+        resolve();
+      }, ms);
+    });
+  });
+}
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/options.js
+var findUnknownOptions = (request, options) => {
+  const unknownOptions = {};
+  for (const key in options) {
+    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && !(key in request)) {
+      unknownOptions[key] = options[key];
+    }
+  }
+  return unknownOptions;
+};
+var hasSearchParameters = (search) => {
+  if (search === void 0) {
+    return false;
+  }
+  if (Array.isArray(search)) {
+    return search.length > 0;
+  }
+  if (search instanceof URLSearchParams) {
+    return search.size > 0;
+  }
+  if (typeof search === "object") {
+    return Object.keys(search).length > 0;
+  }
+  if (typeof search === "string") {
+    return search.trim().length > 0;
+  }
+  return Boolean(search);
+};
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/core/Ky.js
+var _Ky_static, normalizeSearchParams_fn;
+var _Ky = class _Ky {
+  // eslint-disable-next-line complexity
+  constructor(input, options = {}) {
+    __publicField(this, "request");
+    __publicField(this, "abortController");
+    __publicField(this, "_retryCount", 0);
+    __publicField(this, "_input");
+    __publicField(this, "_options");
+    __publicField(this, "_originalRequest");
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    this._input = input;
+    this._options = __spreadProps(__spreadValues({}, options), {
+      headers: mergeHeaders(this._input.headers, options.headers),
+      hooks: mergeHooks({
+        beforeRequest: [],
+        beforeRetry: [],
+        beforeError: [],
+        afterResponse: []
+      }, options.hooks),
+      method: normalizeRequestMethod((_b = (_a = options.method) != null ? _a : this._input.method) != null ? _b : "GET"),
+      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+      prefixUrl: String(options.prefixUrl || ""),
+      retry: normalizeRetryOptions(options.retry),
+      throwHttpErrors: options.throwHttpErrors !== false,
+      timeout: (_c = options.timeout) != null ? _c : 1e4,
+      fetch: (_d = options.fetch) != null ? _d : globalThis.fetch.bind(globalThis)
+    });
+    if (typeof this._input !== "string" && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
+      throw new TypeError("`input` must be a string, URL, or Request");
+    }
+    if (this._options.prefixUrl && typeof this._input === "string") {
+      if (this._input.startsWith("/")) {
+        throw new Error("`input` must not begin with a slash when using `prefixUrl`");
+      }
+      if (!this._options.prefixUrl.endsWith("/")) {
+        this._options.prefixUrl += "/";
+      }
+      this._input = this._options.prefixUrl + this._input;
+    }
+    if (supportsAbortController && supportsAbortSignal) {
+      const originalSignal = (_e = this._options.signal) != null ? _e : this._input.signal;
+      this.abortController = new globalThis.AbortController();
+      this._options.signal = originalSignal ? AbortSignal.any([originalSignal, this.abortController.signal]) : this.abortController.signal;
+    }
+    if (supportsRequestStreams) {
+      this._options.duplex = "half";
+    }
+    if (this._options.json !== void 0) {
+      this._options.body = (_h = (_g = (_f = this._options).stringifyJson) == null ? void 0 : _g.call(_f, this._options.json)) != null ? _h : JSON.stringify(this._options.json);
+      this._options.headers.set("content-type", (_i = this._options.headers.get("content-type")) != null ? _i : "application/json");
+    }
+    this.request = new globalThis.Request(this._input, this._options);
+    if (hasSearchParameters(this._options.searchParams)) {
+      const textSearchParams = typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(__privateMethod(_j = _Ky, _Ky_static, normalizeSearchParams_fn).call(_j, this._options.searchParams)).toString();
+      const searchParams = "?" + textSearchParams;
+      const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
+      if ((supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers["content-type"])) {
+        this.request.headers.delete("content-type");
+      }
+      this.request = new globalThis.Request(new globalThis.Request(url, __spreadValues({}, this.request)), this._options);
+    }
+    if (this._options.onUploadProgress) {
+      if (typeof this._options.onUploadProgress !== "function") {
+        throw new TypeError("The `onUploadProgress` option must be a function");
+      }
+      if (!supportsRequestStreams) {
+        throw new Error("Request streams are not supported in your environment. The `duplex` option for `Request` is not available.");
+      }
+      const originalBody = this.request.body;
+      if (originalBody) {
+        this.request = streamRequest(this.request, this._options.onUploadProgress, this._options.body);
+      }
+    }
+  }
+  static create(input, options) {
+    var _a, _b;
+    const ky2 = new _Ky(input, options);
+    const function_ = () => __async(null, null, function* () {
+      if (typeof ky2._options.timeout === "number" && ky2._options.timeout > maxSafeTimeout) {
+        throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
+      }
+      yield Promise.resolve();
+      let response = yield ky2._fetch();
+      for (const hook of ky2._options.hooks.afterResponse) {
+        const modifiedResponse = yield hook(ky2.request, ky2._options, ky2._decorateResponse(response.clone()));
+        if (modifiedResponse instanceof globalThis.Response) {
+          response = modifiedResponse;
+        }
+      }
+      ky2._decorateResponse(response);
+      if (!response.ok && ky2._options.throwHttpErrors) {
+        let error = new HTTPError(response, ky2.request, ky2._options);
+        for (const hook of ky2._options.hooks.beforeError) {
+          error = yield hook(error);
+        }
+        throw error;
+      }
+      if (ky2._options.onDownloadProgress) {
+        if (typeof ky2._options.onDownloadProgress !== "function") {
+          throw new TypeError("The `onDownloadProgress` option must be a function");
+        }
+        if (!supportsResponseStreams) {
+          throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
+        }
+        return streamResponse(response.clone(), ky2._options.onDownloadProgress);
+      }
+      return response;
+    });
+    const isRetriableMethod = ky2._options.retry.methods.includes(ky2.request.method.toLowerCase());
+    const result = (isRetriableMethod ? ky2._retry(function_) : function_()).finally(() => __async(null, null, function* () {
+      var _a2, _b2;
+      const originalRequest = ky2._originalRequest;
+      const cleanupPromises = [];
+      if (originalRequest && !originalRequest.bodyUsed) {
+        cleanupPromises.push((_a2 = originalRequest.body) == null ? void 0 : _a2.cancel());
+      }
+      if (!ky2.request.bodyUsed) {
+        cleanupPromises.push((_b2 = ky2.request.body) == null ? void 0 : _b2.cancel());
+      }
+      yield Promise.all(cleanupPromises);
+    }));
+    for (const [type, mimeType] of Object.entries(responseTypes)) {
+      if (type === "bytes" && typeof ((_b = (_a = globalThis.Response) == null ? void 0 : _a.prototype) == null ? void 0 : _b.bytes) !== "function") {
+        continue;
+      }
+      result[type] = () => __async(null, null, function* () {
+        ky2.request.headers.set("accept", ky2.request.headers.get("accept") || mimeType);
+        const response = yield result;
+        if (type === "json") {
+          if (response.status === 204) {
+            return "";
+          }
+          const text = yield response.text();
+          if (text === "") {
+            return "";
+          }
+          if (options.parseJson) {
+            return options.parseJson(text);
+          }
+          return JSON.parse(text);
+        }
+        return response[type]();
+      });
+    }
+    return result;
+  }
+  _calculateRetryDelay(error) {
+    var _a, _b, _c, _d;
+    this._retryCount++;
+    if (this._retryCount > this._options.retry.limit || error instanceof TimeoutError) {
+      throw error;
+    }
+    if (error instanceof HTTPError) {
+      if (!this._options.retry.statusCodes.includes(error.response.status)) {
+        throw error;
+      }
+      const retryAfter = (_c = (_b = (_a = error.response.headers.get("Retry-After")) != null ? _a : error.response.headers.get("RateLimit-Reset")) != null ? _b : error.response.headers.get("X-RateLimit-Reset")) != null ? _c : error.response.headers.get("X-Rate-Limit-Reset");
+      if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
+        let after = Number(retryAfter) * 1e3;
+        if (Number.isNaN(after)) {
+          after = Date.parse(retryAfter) - Date.now();
+        } else if (after >= Date.parse("2024-01-01")) {
+          after -= Date.now();
+        }
+        const max = (_d = this._options.retry.maxRetryAfter) != null ? _d : after;
+        return after < max ? after : max;
+      }
+      if (error.response.status === 413) {
+        throw error;
+      }
+    }
+    const retryDelay = this._options.retry.delay(this._retryCount);
+    return Math.min(this._options.retry.backoffLimit, retryDelay);
+  }
+  _decorateResponse(response) {
+    if (this._options.parseJson) {
+      response.json = () => __async(this, null, function* () {
+        return this._options.parseJson(yield response.text());
+      });
+    }
+    return response;
+  }
+  _retry(function_) {
+    return __async(this, null, function* () {
+      try {
+        return yield function_();
+      } catch (error) {
+        const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
+        if (this._retryCount < 1) {
+          throw error;
+        }
+        yield delay(ms, { signal: this._options.signal });
+        for (const hook of this._options.hooks.beforeRetry) {
+          const hookResult = yield hook({
+            request: this.request,
+            options: this._options,
+            error,
+            retryCount: this._retryCount
+          });
+          if (hookResult === stop) {
+            return;
+          }
+        }
+        return this._retry(function_);
+      }
+    });
+  }
+  _fetch() {
+    return __async(this, null, function* () {
+      for (const hook of this._options.hooks.beforeRequest) {
+        const result = yield hook(this.request, this._options);
+        if (result instanceof Request) {
+          this.request = result;
+          break;
+        }
+        if (result instanceof Response) {
+          return result;
+        }
+      }
+      const nonRequestOptions = findUnknownOptions(this.request, this._options);
+      this._originalRequest = this.request;
+      this.request = this._originalRequest.clone();
+      if (this._options.timeout === false) {
+        return this._options.fetch(this._originalRequest, nonRequestOptions);
+      }
+      return timeout(this._originalRequest, nonRequestOptions, this.abortController, this._options);
+    });
+  }
+};
+_Ky_static = new WeakSet();
+normalizeSearchParams_fn = function(searchParams) {
+  if (searchParams && typeof searchParams === "object" && !Array.isArray(searchParams) && !(searchParams instanceof URLSearchParams)) {
+    return Object.fromEntries(Object.entries(searchParams).filter(([, value]) => value !== void 0));
+  }
+  return searchParams;
+};
+__privateAdd(_Ky, _Ky_static);
+var Ky = _Ky;
+
+// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/index.js
+var createInstance = (defaults) => {
+  const ky2 = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
+  for (const method of requestMethods) {
+    ky2[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, { method }));
+  }
+  ky2.create = (newDefaults) => createInstance(validateAndMerge(newDefaults));
+  ky2.extend = (newDefaults) => {
+    if (typeof newDefaults === "function") {
+      newDefaults = newDefaults(defaults != null ? defaults : {});
+    }
+    return createInstance(validateAndMerge(defaults, newDefaults));
+  };
+  ky2.stop = stop;
+  return ky2;
+};
+var ky = createInstance();
+var distribution_default = ky;
+
+// src/zupost.ts
+var Zupost = class {
+  constructor(apiKey, apiUrl) {
+    this.apiKey = apiKey;
+    this.apiUrl = apiUrl;
+    this.baseUrl = "https://api.zupost.com";
+    if (!apiKey) {
+      throw new Error("API key is required");
+    }
+    if (apiUrl) {
+      this.baseUrl = apiUrl;
+    }
+    this.headers = new Headers({
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "User-Agent": `node-sdk@${version}`
+    });
+  }
+  request(path, method, body) {
+    return __async(this, null, function* () {
+      return distribution_default(path, {
+        headers: this.headers,
+        method,
+        retry: 3,
+        prefixUrl: this.baseUrl,
+        body
+      }).json();
+    });
+  }
+  get(path) {
+    return __async(this, null, function* () {
+      return this.request(path, "GET");
+    });
+  }
+  post(path, body) {
+    return __async(this, null, function* () {
+      return this.request(path, "POST", body);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Zupost
+});
+/*! Bundled license information:
+
+ky/distribution/index.js:
+  (*! MIT License © Sindre Sorhus *)
+*/